Merge branch 'feat/claimStructure' into 'dev'

Feat/claim structure

See merge request web-et-numerique/pamn_plateforme-des-acteurs-de-la-mediation-numerique/pamn_client!50

src/app/app.component.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { TestBed } from '@angular/core/testing';
 import { RouterTestingModule } from '@angular/router/testing';
 import { AppComponent } from './app.component';
@@ -5,7 +6,7 @@ import { AppComponent } from './app.component';
 describe('AppComponent', () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      imports: [RouterTestingModule],
+      imports: [RouterTestingModule, HttpClientTestingModule],
       declarations: [AppComponent],
     }).compileComponents();
   });

src/app/form/form.component.scss

-form {
+.form {
   position: fixed;
   background: white;
-  width: 100vh;
+  width: 50vw;
   height: 100vh;
   top: 0;
   z-index: 9999;

src/app/form/form.component.spec.ts

 import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { FormArray, FormControl, FormGroup, Validators } from '@angular/forms';
+import { FormArray, FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
 import { Time } from '../models/time.model';
+import { SharedModule } from '../shared/shared.module';
 
 import { FormComponent } from './form.component';
 
-fdescribe('FormComponent', () => {
+describe('FormComponent', () => {
   let component: FormComponent;
   let fixture: ComponentFixture<FormComponent>;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [FormComponent],
-      imports: [HttpClientTestingModule],
+      imports: [HttpClientTestingModule, FormsModule, ReactiveFormsModule, SharedModule],
     }).compileComponents();
   });
 

src/app/form/form.component.ts

@@ -11,6 +11,7 @@ import { EquipmentAccess } from '../shared/enum/equipmentAccess.enum';
 import { WeekDayEnum } from '../shared/enum/weekDay.enum';
 import { typeStructureEnum } from '../shared/enum/typeStructure.enum';
 import { FonctionContactEnum } from '../shared/enum/fonctionContact.enum';
+import { ProfileService } from '../profile/services/profile.service';
 import { User } from '../models/user.model';
 
 @Component({
@@ -20,9 +21,13 @@ import { User } from '../models/user.model';
 })
 export class FormComponent implements OnInit {
   @Input() public idStructure?: number;
+  @Input() public isEditMode: boolean;
   @Input() public profile?: User;
   @Output() closeEvent = new EventEmitter<Structure>();
   public structureForm: FormGroup;
+
+  public userAlreadyExist = false;
+
   public equipmentAccess = EquipmentAccess;
   public weekDay = WeekDayEnum;
   public typeStructure = typeStructureEnum;
@@ -35,7 +40,11 @@ export class FormComponent implements OnInit {
   public equipmentsAndServices: Category;
   public proceduresAccompaniment: Category;
   public structureId: number;
-  constructor(private structureService: StructureService, private searchService: SearchService) {}
+  constructor(
+    private structureService: StructureService,
+    private searchService: SearchService,
+    private profileService: ProfileService
+  ) {}
 
   ngOnInit(): void {
     if (this.idStructure) {
@@ -75,6 +84,7 @@ export class FormComponent implements OnInit {
         }
       });
     });
+
     this.searchService.getCategoriesTraining().subscribe((t) => {
       this.categoryTraining = t;
     });
@@ -143,6 +153,13 @@ export class FormComponent implements OnInit {
       equipmentsDetails: new FormControl(structure.equipmentsDetails),
       equipmentsAccessType: this.loadArrayForCheckbox(structure.equipmentsAccessType, false),
     });
+
+    // Disable form when it's to claim.
+    if (!this.isEditMode && this.idStructure) {
+      Object.keys(this.structureForm.controls).forEach((controlName) => {
+        this.structureForm.controls[controlName].disable();
+      });
+    }
   }
 
   private loadArrayForCheckbox(array: string[], isRequired: boolean): FormArray {
@@ -151,7 +168,6 @@ export class FormComponent implements OnInit {
       isRequired ? Validators.required : Validators.nullValidator
     );
   }
-
   public getStructureControl(nameControl: string): AbstractControl {
     return this.structureForm.get(nameControl);
   }
@@ -186,8 +202,8 @@ export class FormComponent implements OnInit {
   }
   private createTime(time: Time): FormGroup {
     return new FormGroup({
-      openning: new FormControl(time.openning, Validators.required),
-      closing: new FormControl(time.closing, Validators.required),
+      openning: new FormControl(time.openning),
+      closing: new FormControl(time.closing),
     });
   }
 
@@ -228,24 +244,34 @@ export class FormComponent implements OnInit {
     }
     return false;
   }
+  public onSubmitClaim(accountForm: FormGroup): void {
+    if (!this.structureForm.invalid && accountForm.valid) {
+      this.profileService.createUserandLinkStructure(this.structureId, accountForm.value).subscribe((user) => {
+        this.closeEvent.emit(this.structureForm.value);
+      });
+    }
+  }
+
+  public onSubmitClaimWithAccount(): void {
+    this.structureService
+      .claimStructureWithAccount(this.structureId, this.profile.email)
+      .subscribe((structuresLinked) => {
+        this.profile.structuresLink = structuresLinked;
+        this.profileService.setProfile(this.profile);
+        this.closeEvent.emit(this.structureForm.value);
+      });
+  }
   public onSubmit(structureForm: FormGroup): void {
     if (structureForm.valid) {
       if (this.structureId) {
-        this.structureService.postStructure(this.structureId, structureForm.value).subscribe(
-          (structure: Structure) => {
-            this.closeEvent.emit(structure);
-          },
-          (err) => {}
-        );
+        this.structureService.editStructure(this.structureId, structureForm.value).subscribe((structure: Structure) => {
+          this.closeEvent.emit(structure);
+        });
       } else {
-        this.structureService.createStructure(structureForm.value, this.profile).subscribe(
-          (structure: Structure) => {
-            this.closeEvent.emit(structure);
-          },
-          (err) => {}
-        );
+        this.structureService.createStructure(structureForm.value, this.profile).subscribe((structure: Structure) => {
+          this.closeEvent.emit(structure);
+        });
       }
-    } else {
     }
   }
 }

src/app/header/header.component.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { RouterTestingModule } from '@angular/router/testing';
 
@@ -9,7 +10,7 @@ describe('HeaderComponent', () => {
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      imports: [RouterTestingModule],
+      imports: [RouterTestingModule, HttpClientTestingModule],
       declarations: [HeaderComponent],
     }).compileComponents();
   });

src/app/map/services/map.service.spec.ts

@@ -22,22 +22,22 @@ describe('MapService', () => {
   });
   it('should add marker to map with icon ic_marker.png', () => {
     const marker = service.createMarker(45.764043, 4.835659, 1);
-    expect(marker.getIcon().options.iconSize).toEqual([35, 41]);
-    expect(marker.getIcon().options.iconAnchor).toEqual([13, 41]);
+    expect(marker.getIcon().options.iconSize).toEqual([19, 24]);
+    expect(marker.getIcon().options.iconAnchor).toEqual([9, 0]);
   });
 
-  it('should cerate marker with tooltip', () => {
-    const marker = service.createMarker(45.764043, 4.835659, 1, '<p>Hello <br/>World !</p>');
+  it('should cerate marker with popup', () => {
+    const marker = service.createMarker(45.764043, 4.835659, 1, null, '<p>Hello <br/>World !</p>');
 
-    expect(marker.getTooltip().getContent()).toEqual('<p>Hello <br/>World !</p>');
+    expect(marker.getPopup().getContent()).toEqual('<p>Hello <br/>World !</p>');
   });
 
   it('should get marker', () => {
-    const marker = service.createMarker(45.764043, 4.835659, 1, '<p>Hello <br/>World !</p>');
-    expect(marker).toEqual(service.getMarker(1));
+    const marker = service.createMarker(45.764043, 4.835659, 1, 53, '<p>Hello <br/>World !</p>');
+    expect(marker).toEqual(service.getMarker(53));
   });
   it('should not get marker, with missing id', () => {
-    service.createMarker(45.764043, 4.835659, 1, '<p>Hello <br/>World !</p>');
+    service.createMarker(45.764043, 4.835659, 1, null, '<p>Hello <br/>World !</p>');
     expect(service.getMarker(2)).toEqual(null);
   });
   it('should not get marker, empty', () => {

src/app/profile/profile.component.html

@@ -4,6 +4,12 @@
     <div *ngIf="userProfile" fxLayout="column" fxLayoutAlign="center" fxLayoutGap="10px">
       <p>Id: {{ userProfile._id }}</p>
       <p>Email: {{ userProfile.email }}</p>
+      <p>
+        Mes structures :
+        <span *ngFor="let structureId of userProfile.structuresLink">
+          <b>{{ structureId }}</b>
+        </span>
+      </p>
       <button (click)="toogleAddStructure()">Ajouter une structure</button>
       <button (click)="toogleChangeEmail()">Changer d'email</button>
       <form

src/app/profile/profile.component.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ReactiveFormsModule } from '@angular/forms';
 
 import { ProfileComponent } from './profile.component';
 
@@ -8,9 +10,9 @@ describe('ProfileComponent', () => {
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      declarations: [ ProfileComponent ]
-    })
-    .compileComponents();
+      declarations: [ProfileComponent],
+      imports: [HttpClientTestingModule, ReactiveFormsModule],
+    }).compileComponents();
   });
 
   beforeEach(() => {

src/app/profile/services/profile.service.ts

@@ -2,7 +2,6 @@ import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { User } from '../../models/user.model';
-import { AuthService } from '../../services/auth.service';
 
 @Injectable({
   providedIn: 'root',
@@ -10,27 +9,37 @@ import { AuthService } from '../../services/auth.service';
 export class ProfileService {
   private readonly baseUrl = 'api/users';
   private currentProfile: User = null;
-  constructor(private http: HttpClient, private authService: AuthService) {}
+  constructor(private http: HttpClient) {}
 
   public async getProfile(): Promise<User> {
     // Get profil by API only on first time
-    if (!this.currentProfile && this.authService.isLoggedIn()) {
+    if (!this.currentProfile) {
       const profile = await this.http.get<User>(`${this.baseUrl}/profile`).toPromise();
       this.currentProfile = profile;
     }
     return this.currentProfile;
   }
 
+  public setProfile(profile: User): void {
+    this.currentProfile = profile;
+  }
+
   public isLinkedToStructure(idStructure: number): boolean {
-    if (!this.authService.isLoggedIn()) {
-      this.currentProfile = null;
-    }
     if (!this.currentProfile) {
       return false;
     }
     return this.currentProfile.structuresLink.includes(idStructure);
   }
 
+  public removeProfile(): void {
+    this.currentProfile = null;
+  }
+
+  public createUserandLinkStructure(id: number, body: User): Observable<User> {
+    body.structuresLink = [id];
+    return this.http.post<any>(`${this.baseUrl}`, body);
+  }
+
   public changePassword(newPassword: string, oldPassword: string): Observable<User> {
     return this.http.post<any>(`${this.baseUrl}/change-password`, { newPassword, oldPassword });
   }

src/app/reset-email/reset-email.component.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
 
 import { ResetEmailComponent } from './reset-email.component';
 
@@ -9,6 +11,7 @@ describe('ResetEmailComponent', () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [ResetEmailComponent],
+      imports: [RouterTestingModule, HttpClientTestingModule],
     }).compileComponents();
   });
 

src/app/reset-password/reset-password.component.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ReactiveFormsModule } from '@angular/forms';
+import { RouterTestingModule } from '@angular/router/testing';
 
 import { ResetPasswordComponent } from './reset-password.component';
 
@@ -8,9 +11,9 @@ describe('ResetPasswordComponent', () => {
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      declarations: [ ResetPasswordComponent ]
-    })
-    .compileComponents();
+      declarations: [ResetPasswordComponent],
+      imports: [ReactiveFormsModule, HttpClientTestingModule, RouterTestingModule],
+    }).compileComponents();
   });
 
   beforeEach(() => {

src/app/services/auth.service.spec.ts

+import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { TestBed } from '@angular/core/testing';
 
 import { AuthService } from './auth.service';
@@ -6,7 +7,9 @@ describe('AuthService', () => {
   let service: AuthService;
 
   beforeEach(() => {
-    TestBed.configureTestingModule({});
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
     service = TestBed.inject(AuthService);
   });
 

src/app/services/structure.service.ts

@@ -17,24 +17,33 @@ import { User } from '../models/user.model';
   providedIn: 'root',
 })
 export class StructureService {
+  private readonly baseUrl = 'api/structures';
   constructor(private http: HttpClient) {}
 
   public createStructure(structure: Structure, profile: User): Observable<Structure> {
     const idUser = profile.email;
-    return this.http.post('/api/structures', { structure, idUser }).pipe(map((item: Structure) => new Structure(item)));
+    return this.http.post(`${this.baseUrl}`, { structure, idUser }).pipe(map((item: Structure) => new Structure(item)));
   }
 
-  public postStructure(id: number, structure: Structure): Observable<Structure> {
+  public editStructure(id: number, structure: Structure): Observable<Structure> {
     structure.updatedAt = new Date().toString();
-    return this.http.post('/api/structures/' + id, structure).pipe(map((item: Structure) => new Structure(item)));
+    return this.http.put(`${this.baseUrl}/${id}`, structure).pipe(map((item: Structure) => new Structure(item)));
+  }
+
+  public isClaimed(id: number): Observable<any> {
+    return this.http.get(`${this.baseUrl}/${id}/isClaimed`);
+  }
+
+  public claimStructureWithAccount(id: number, email: string): Observable<number[]> {
+    return this.http.post<any>(`${this.baseUrl}/${id}/claim`, { email });
   }
 
   public getStructure(id: number): Observable<Structure> {
-    return this.http.get('/api/structures/' + id).pipe(map((item: any) => new Structure(item)));
+    return this.http.get(`${this.baseUrl}/${id}`).pipe(map((item: any) => new Structure(item)));
   }
   public getStructures(filters: Filter[]): Observable<Structure[]> {
     if (filters && filters.length > 0) {
-      let requestUrl = '/api/structures/search';
+      let requestUrl = `${this.baseUrl}/search`;
       const queryString = _.find(filters, { name: 'query' });
       if (queryString) {
         _.remove(filters, { name: 'query' });
@@ -45,7 +54,7 @@ export class StructureService {
         .post(requestUrl, { filters: formatedFilters })
         .pipe(map((data: any[]) => data.map((item) => new Structure(item))));
     } else {
-      return this.http.get('/api/structures').pipe(map((data: any[]) => data.map((item) => new Structure(item))));
+      return this.http.get(`${this.baseUrl}`).pipe(map((data: any[]) => data.map((item) => new Structure(item))));
     }
   }
 

src/app/shared/components/create-account-form/create-account-form.component.html

+<form [formGroup]="accountForm" *ngIf="accountForm" (ngSubmit)="onSubmit(accountForm)">
+  <div class="form-group">
+    <label for="email">Email</label>
+    <input type="email" autocomplete="on" formControlName="email" class="form-control" />
+    <app-validator-form *ngIf="submitted" [control]="getAccountControl('email')"></app-validator-form>
+  </div>
+  <div class="form-group">
+    <label for="password">Mot de passe</label>
+    <input type="password" autocomplete="on" formControlName="password" class="form-control" />
+    <app-validator-form
+      *ngIf="submitted"
+      [nameControl]="'password'"
+      [control]="getAccountControl('password')"
+    ></app-validator-form>
+  </div>
+  <div class="form-group">
+    <label for="confirmPassword">Confirmation du mot de passe</label>
+    <input type="password" autocomplete="on" formControlName="confirmPassword" class="form-control" />
+    <app-validator-form
+      *ngIf="submitted"
+      [nameControl]="'password'"
+      [control]="getAccountControl('confirmPassword')"
+    ></app-validator-form>
+  </div>
+
+  <div class="form-group">
+    <button class="btn btn-primary" type="submit">Valider</button>
+  </div>
+</form>

src/app/shared/components/create-account-form/create-account-form.component.spec.ts

+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, FormGroup, Validators } from '@angular/forms';
+import { MustMatch } from '../../validator/form';
+
+import { CreateAccountFormComponent } from './create-account-form.component';
+
+describe('CreateAccountFormComponent', () => {
+  let component: CreateAccountFormComponent;
+  let fixture: ComponentFixture<CreateAccountFormComponent>;
+  const accountForm = new FormGroup(
+    {
+      email: new FormControl('test@test.fr', Validators.required),
+      password: new FormControl('Testaze123!', [
+        Validators.required,
+        Validators.pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{8,})/),
+      ]),
+      confirmPassword: new FormControl('Testaze123!'),
+    },
+    [MustMatch('password', 'confirmPassword')]
+  );
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [CreateAccountFormComponent],
+    }).compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CreateAccountFormComponent);
+    component = fixture.componentInstance;
+
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should emit the form', () => {
+    spyOn(component.submitForm, 'emit');
+    component.onSubmit(accountForm);
+    expect(component.submitForm.emit).toHaveBeenCalled();
+    expect(component.submitForm.emit).toHaveBeenCalledWith(accountForm);
+  });
+
+  it('should return control', () => {
+    component.accountForm = accountForm;
+    const result = component.getAccountControl('email');
+    const control = accountForm.get('email');
+    expect(result).toEqual(control);
+  });
+});

src/app/shared/components/create-account-form/create-account-form.component.ts

+import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';
+import { AbstractControl, FormControl, FormGroup, Validators } from '@angular/forms';
+import { MustMatch } from '../../validator/form';
+
+@Component({
+  selector: 'app-create-account-form',
+  templateUrl: './create-account-form.component.html',
+  styleUrls: ['./create-account-form.component.scss'],
+})
+export class CreateAccountFormComponent implements OnInit {
+  constructor() {}
+  public accountForm: FormGroup;
+  public submitted: boolean = false;
+  @Output() public submitForm = new EventEmitter<FormGroup>();
+
+  ngOnInit(): void {
+    this.accountForm = new FormGroup(
+      {
+        email: new FormControl('', Validators.required),
+        password: new FormControl('', [
+          Validators.required,
+          Validators.pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{8,})/),
+        ]),
+        confirmPassword: new FormControl(''),
+      },
+      [MustMatch('password', 'confirmPassword')]
+    );
+  }
+
+  public onSubmit(accountForm: FormGroup) {
+    this.submitted = true;
+    if (accountForm.valid) {
+      this.submitForm.emit(accountForm);
+    }
+  }
+
+  public getAccountControl(nameControl: string): AbstractControl {
+    return this.accountForm.get(nameControl);
+  }
+}

src/app/shared/components/index.ts

@@ -5,6 +5,7 @@ import { SignUpModalComponent } from './signup-modal/signup-modal.component';
 import { SignInModalComponent } from './signin-modal/signin-modal.component';
 import { SvgIconComponent } from './svg-icon/svg-icon.component';
 import { ValidatorFormComponent } from './validator-form/validator-form.component';
+import { CreateAccountFormComponent } from './create-account-form/create-account-form.component';
 
 // tslint:disable-next-line: max-line-length
 export {
@@ -15,6 +16,7 @@ export {
   ValidatorFormComponent,
   SignUpModalComponent,
   SignInModalComponent,
+  CreateAccountFormComponent,
 };
 
 // tslint:disable-next-line:variable-name
@@ -26,4 +28,5 @@ export const SharedComponents = [
   ValidatorFormComponent,
   SignUpModalComponent,
   SignInModalComponent,
+  CreateAccountFormComponent,
 ];

src/app/shared/components/logo-card/logo-card.component.spec.ts

@@ -24,13 +24,11 @@ describe('LogoCardComponent', () => {
   });
 
   it('should return logo name with a string input', () => {
-    const logoCaf = component.getLogoKey(Demarches.caf);
-    const logoCarsat = component.getLogoKey(Demarches.carsat);
-    const logoCpam = component.getLogoKey(Demarches.cpam);
-    const logoOther = component.getLogoKey(Demarches.other);
-    expect(logoCaf).toEqual('caf');
-    expect(logoCarsat).toEqual('carsat');
-    expect(logoCpam).toEqual('cpam');
-    expect(logoOther).toEqual('other');
+    const logoCaf = component.getName('accompagnantCaf');
+    const logoCarsat = component.getName('carsat');
+    const logoCpam = component.getName('cpam');
+    expect(logoCaf).toEqual(Demarches.accompagnantCaf);
+    expect(logoCarsat).toEqual(Demarches.carsat);
+    expect(logoCpam).toEqual(Demarches.cpam);
   });
 });