ajout du niveau d'experience

README.md

@@ -1,16 +1,59 @@
-# Projet 4
+# ApiLibraryFrontend
 
-Voici le projet 4 
+This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 20.3.9.
 
-## Membres
+## Development server
 
-Carteron Mathieu
-Lallois Ily
-Barbier Gavin
+To start a local development server, run:
 
-## Objectif
+```bash
+ng serve
+```
 
-Nous sommes responsable du développement du module dédié à la gestion des relations
-clients et prestataires pour Pyro-Fêtes. Ce module va devoir permettre de centraliser les
-informations sur les clients, les prestataires les artificiers et les différents contacts, de suivre
-les interactions, ainsi que garantir la conformité réglementaire.
+Once the server is running, open your browser and navigate to `http://localhost:4200/`. The application will automatically reload whenever you modify any of the source files.
+
+## Code scaffolding
+
+Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
+
+```bash
+ng generate component component-name
+```
+
+For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
+
+```bash
+ng generate --help
+```
+
+## Building
+
+To build the project run:
+
+```bash
+ng build
+```
+
+This will compile your project and store the build artifacts in the `dist/` directory. By default, the production build optimizes your application for performance and speed.
+
+## Running unit tests
+
+To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:
+
+```bash
+ng test
+```
+
+## Running end-to-end tests
+
+For end-to-end (e2e) testing, run:
+
+```bash
+ng e2e
+```
+
+Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
+
+## Additional Resources
+
+For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

openapi-generator.yaml

@@ -0,0 +1,3 @@
+additionalProperties:
+  fileNaming: kebab-case
+  modelPropertyNaming: camelCase

openapitools.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "./node_modules/@openapitools/openapi-generator-cli/config.schema.json",
+  "spaces": 2,
+  "generator-cli": {
+    "version": "7.17.0"
+  }
+}

package.json

@@ -5,7 +5,8 @@
     "ng": "ng",
     "start": "ng serve",
     "build": "ng build",
-    "watch": "ng build --watch --configuration development"
+    "watch": "ng build --watch --configuration development",
+    "openapi": "rimraf src/app/services/api && openapi-generator-cli generate -i http://localhost:5298/swagger/v1/swagger.json -g typescript-angular -o src/app/services/api -c openapi-generator.yaml"
   },
   "prettier": {
     "printWidth": 100,
@@ -27,6 +28,7 @@
     "@angular/forms": "^20.3.0",
     "@angular/platform-browser": "^20.3.0",
     "@angular/router": "^20.3.0",
+    "@openapitools/openapi-generator-cli": "^2.25.2",
     "@tailwindcss/postcss": "^4.1.17",
     "ng-zorro-antd": "^20.4.0",
     "postcss": "^8.5.6",
@@ -40,6 +42,7 @@
     "@angular/cli": "^20.3.10",
     "@angular/compiler-cli": "^20.3.0",
     "less": "^4.2.0",
+    "rimraf": "^6.1.3",
     "typescript": "~5.9.2"
   }
 }

src/app/app.config.ts

@@ -7,6 +7,7 @@ import { registerLocaleData } from '@angular/common';
 import fr from '@angular/common/locales/fr';
 import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
 import { provideHttpClient } from '@angular/common/http';
+import {NzModalService} from 'ng-zorro-antd/modal';
 
 registerLocaleData(fr);
 
@@ -14,6 +15,7 @@ export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
     provideZoneChangeDetection({ eventCoalescing: true }),
-    provideRouter(routes), provideNzI18n(fr_FR), provideAnimationsAsync(), provideHttpClient()
+    provideRouter(routes), provideNzI18n(fr_FR), provideAnimationsAsync(), provideHttpClient(),
+    NzModalService
   ]
 };

src/app/app.css

@@ -3,11 +3,27 @@
 }
 
 .app-layout {
-  height: 100vh;
+    height: 150vh;
+    width: 100%;
+}
+
+.main-title {
+    color:#eabf63;
 }
 
 .top-nav {
   line-height: 64px;
+  background-color: #2c2c2c;
+}
+
+.top-nav a {
+    display: block;
+    background-color: #4c4c4c;
+}
+
+.nav-item {
+    color: #eabf63;
+    font-size: 18px;
 }
 
 .logo {
@@ -15,22 +31,21 @@
   height: 64px;
   padding-right: 24px;
   line-height: 64px;
-  background: #001529;
+  background: #1c1c1c;
 }
 
 .logo img {
   display: inline-block;
-  height: 32px;
-  width: 32px;
-  vertical-align: middle;
+    height: 70px;
+    width: 130px;
 }
 
 .logo h1 {
   display: inline-block;
-  margin: 0 0 0 15px;
-  color: #fff;
+  margin: 0 0 0 10px;
+  color: #eabf63;
   font-weight: 600;
-  font-size: 20px;
+  font-size: 22px;
   font-family: Avenir,Helvetica Neue,Arial,Helvetica,sans-serif;
   vertical-align: middle;
 }

src/app/app.html

@@ -2,16 +2,17 @@
   <nz-header>
     <div class="logo">
       <a>
-        <img src="../logo.svg" alt="logo">
-        <h1>Pyrofêtes P4</h1>
+         <img src="../logo-navbar.svg" alt="logo">
+         <h1>Gestion des relations</h1>
       </a>
     </div>
-    <ul nz-menu class="top-nav" nzTheme="dark" nzMode="horizontal">
-      <li nz-menu-item routerLinkActive="ant-menu-item-selected" routerLink="/customers">Clients</li>
-      <li nz-menu-item routerLinkActive="ant-menu-item-selected" routerLink="/providers">Prestataires</li>
-      <li nz-menu-item routerLinkActive="ant-menu-item-selected" routerLink="/staff">Artificiers</li>
-        <li nz-menu-item routerLinkActive="ant-menu-item-selected" routerLink="/opportunities">Opportunités</li>
-    </ul>
+     <ul nz-menu class="top-nav" nzTheme="dark" nzMode="horizontal">
+         <li nz-menu-item class="nav-item" routerLinkActive="ant-menu-item-selected" routerLink="/contact"><nz-icon nzType="user" nzTheme="outline" /> Contact </li>
+         <li nz-menu-item class="nav-item" routerLinkActive="ant-menu-item-selected" routerLink="/customers"><nz-icon nzType="shop" nzTheme="outline" /> Clients</li>
+         <li nz-menu-item class="nav-item" routerLinkActive="ant-menu-item-selected" routerLink="/providers"><nz-icon nzType="solution" nzTheme="outline" /> Prestataires</li>
+         <li nz-menu-item class="nav-item" routerLinkActive="ant-menu-item-selected" routerLink="/staff"><nz-icon nzType="fire" nzTheme="fill" /> Artificiers</li>
+         <li nz-menu-item class="nav-item" routerLinkActive="ant-menu-item-selected" routerLink="/opportunities"><nz-icon nzType="stock" nzTheme="outline" /> Opportunités</li>
+     </ul>
   </nz-header>
   <nz-content>
     <div class="inner-content">

src/app/app.routes.ts

@@ -7,8 +7,12 @@ export const routes: Routes = [
       redirectTo: '/customers'
   },
           {
-          path:'customers',
-          loadComponent: () => import('./pages/customers/customers').then(x => x.Customers)
+              path:'contact',
+              loadComponent: () => import('./pages/contact/contact').then(x => x.Contact)
+          },
+          {
+              path:'customers',
+              loadComponent: () => import('./pages/customers/customers').then(x => x.Customers)
           },
 
           {

src/app/app.ts

@@ -2,10 +2,11 @@ import { Component } from '@angular/core';
 import {RouterLink, RouterLinkActive, RouterOutlet} from '@angular/router';
 import { NzLayoutModule } from 'ng-zorro-antd/layout';
 import { NzMenuModule } from 'ng-zorro-antd/menu';
+import {NzIconDirective} from "ng-zorro-antd/icon";
 
 @Component({
   selector: 'app-root',
-  imports: [RouterOutlet, NzLayoutModule, NzMenuModule, RouterLinkActive, RouterLink],
+    imports: [RouterOutlet, NzLayoutModule, NzMenuModule, RouterLinkActive, RouterLink, NzIconDirective],
   templateUrl: './app.html',
   styleUrl: './app.css'
 })

src/app/pages/contact/contact-add-form/contact-add-form.html

@@ -0,0 +1,61 @@
+<form nz-form nzLayout="horizontal" [formGroup]="contactForm">
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Nom</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Nom" formControlName="lastName">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Prénom</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Prénom" formControlName="firstName">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Email</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Email" formControlName="email">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Téléphone</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Téléphone" formControlName="phoneNumber">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Adresse</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Adresse" formControlName="address">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Code postal</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input type="number" placeholder="Code postal" formControlName="zipCode">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Ville</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Ville" formControlName="city">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Rôle</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Rôle" formControlName="role">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-flex nzJustify="end">
+        <button nz-button nzType="primary" (click)="submitForm()">Valider</button>
+    </nz-flex>
+</form>

src/app/pages/contact/contact-add-form/contact-add-form.ts

@@ -0,0 +1,89 @@
+import {Component, inject, signal} from '@angular/core';
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzColDirective} from "ng-zorro-antd/grid";
+import {NzFlexDirective} from "ng-zorro-antd/flex";
+import {ContactsService, CreateContactDto} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+
+@Component({
+  selector: 'app-contact-add-form',
+  imports: [
+    NzFormLabelComponent,
+    NzFormItemComponent,
+    NzFormControlComponent,
+    NzInputDirective,
+    ReactiveFormsModule,
+    NzColDirective,
+    NzFormDirective,
+    NzFlexDirective,
+    NzButtonComponent
+  ],
+  templateUrl: './contact-add-form.html',
+  styleUrl: './contact-add-form.css',
+})
+export class ContactAddForm {
+    private contactsService = inject(ContactsService);
+    private notificationService = inject(NzNotificationService);
+
+    contactForm = new FormGroup({
+      lastName: new FormControl<string>(null, [Validators.required]),
+      firstName: new FormControl<string>(null, [Validators.required]),
+      phoneNumber: new FormControl<string>(null, [Validators.required]),
+      email: new FormControl<string>(null, [Validators.required]),
+      address: new FormControl<string>(null, [Validators.required]),
+      city: new FormControl<string>(null, [Validators.required]),
+      role: new FormControl<string>(null, [Validators.required]),
+      customerId: new FormControl<number>(null),
+    })
+
+    contactPost = signal<CreateContactDto>(this.contactForm.value);
+    contactsLoading = signal<boolean>(false);
+
+    async submitForm() {
+      if (this.contactForm.invalid) return;
+
+      console.log(this.contactForm.getRawValue())
+      this.contactPost.set(this.contactForm.getRawValue())
+
+      await this.createContact(
+          this.contactPost().lastName,
+          this.contactPost().firstName,
+          this.contactPost().phoneNumber,
+          this.contactPost().email,
+          this.contactPost().address,
+          this.contactPost().city,
+          this.contactPost().role,
+          this.contactPost().customerId
+      )
+      this.contactForm.reset()
+    }
+
+    async createContact(lastName: string, firstName: string, phoneNumber: string, email: string, address: string, city: string, role: string, customerId: number) {
+      this.contactsLoading.set(true);
+
+      const contactValue: CreateContactDto = {
+        lastName: lastName,
+        firstName: firstName,
+        phoneNumber: phoneNumber,
+        email: email,
+        address: address,
+        city: city,
+        role: role,
+        customerId: customerId
+      }
+
+      try {
+        const contact = await firstValueFrom(this.contactsService.createContactEndpoint(contactValue));
+        this.contactPost.set(contact);
+        console.log(contact);
+      } catch (e) {
+        this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+      }
+
+      this.contactsLoading.set(false);
+    }
+}

src/app/pages/contact/contact-card/contact-card.html

@@ -0,0 +1,70 @@
+@if (edit() == false) {
+    <nz-card style="width:400px;" [nzActions]="[edit, delete]">
+        <h2 style="text-align: center; font-weight: bold">Contact n°{{ contact().id }}</h2>
+        <p>Nom : {{ contact().lastName + " " + contact().firstName }}</p>
+        <p>Rôle : {{ contact().role }}</p>
+        <p>Numéro de téléphone : {{ contact().phoneNumber }} </p>
+        <p>Email : {{ contact().email }}</p>
+        <p>Adresse : {{ contact().address + ", " + contact().city }}</p>
+
+    </nz-card>
+    <ng-template #edit>
+        <nz-icon (click)="Edit()" nzType="edit" nzTheme="fill" />
+    </ng-template>
+    <ng-template #delete>
+        <nz-icon (click)="Delete()" nzType="delete" nzTheme="fill" />
+    </ng-template>
+} @else {
+    <nz-card style="width:400px;" [nzActions]="[back, check]">
+        <form nz-form nzLayout="horizontal" [formGroup]="contactForm">
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Nom </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Nom" formControlName="lastname">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Prénom </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Prénom" formControlName="firstname">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Num. Tél. </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Numéro de téléphone" formControlName="phone">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Email </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Email" formControlName="email">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Adresse </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Adresse" formControlName="address">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Ville </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Ville" formControlName="city">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Rôle </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Rôle" formControlName="role">
+                </nz-form-control>
+            </nz-form-item>
+        </form>
+    </nz-card>
+    <ng-template #back>
+        <nz-icon (click)="Back()" nzType="backward" nzTheme="fill" />
+    </ng-template>
+    <ng-template #check>
+        <nz-icon (click)="submitForm()" nzType="check" nzTheme="outline" />
+    </ng-template>
+}

src/app/pages/contact/contact-card/contact-card.ts

@@ -0,0 +1,108 @@
+import {Component, inject, input, output, signal} from '@angular/core';
+import {
+  ContactsService,
+  CustomersService, GetContactDto,
+  GetCustomerDto,
+  UpdateContactDto,
+  UpdateCustomerDto
+} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {firstValueFrom} from "rxjs";
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzIconDirective} from "ng-zorro-antd/icon";
+import {NzInputDirective} from "ng-zorro-antd/input";
+
+@Component({
+  selector: 'app-contact-card',
+  imports: [NzCardComponent, NzColDirective, NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent, NzIconDirective, NzInputDirective, NzRowDirective, ReactiveFormsModule],
+  templateUrl: './contact-card.html',
+  styleUrl: './contact-card.css',
+})
+export class ContactCard {
+  private contactsService = inject(ContactsService);
+  private notificationService = inject(NzNotificationService)
+
+  contactEdit = signal<UpdateContactDto>(null);
+  contactsLoading = signal<boolean>(false);
+
+  contactForm = new FormGroup({
+    id: new FormControl(null, [Validators.required]),
+    lastname: new FormControl<string>(null, [Validators.required]),
+    firstname: new FormControl(null, [Validators.required]),
+    phone: new FormControl(null, [Validators.required]),
+    email: new FormControl(null, [Validators.required]),
+    address: new FormControl(null, [Validators.required]),
+    city: new FormControl(null, [Validators.required]),
+    role: new FormControl(null, [Validators.required])
+  })
+
+  async submitForm() {
+    this.contactsLoading.set(true);
+
+    const contactValue = {
+      lastname: this.contactForm.value.lastname,
+      firstname: this.contactForm.value.firstname,
+      phone: this.contactForm.value.phone,
+      email: this.contactForm.value.email,
+      address: this.contactForm.value.address,
+      city: this.contactForm.value.city,
+      role: this.contactForm.value.role,
+    }
+
+    try {
+      const contact = await firstValueFrom(this.contactsService.updateContactEndpoint(this.contact().id,contactValue));
+      this.contactEdit.set(contact);
+      console.log(contact);
+      this.contactForm.reset();
+      this.edit.set(false);
+
+      this.triggerEdited.emit();
+
+    } catch (e)
+    {
+      this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+    }
+
+    this.contactsLoading.set(false);
+
+  }
+
+
+  contact = input<GetContactDto>(null);
+
+  edit = signal(false)
+
+  triggerEdited = output<void>();
+
+  protected Edit() {
+    this.edit.set(true)
+  }
+
+  protected Back() {
+    this.edit.set(false)
+    this.contactForm.reset();
+  }
+
+  async Delete() {
+    this.contactsLoading.set(true);
+
+    try {
+      const contact = await firstValueFrom(this.contactsService.deleteContactEndpoint(this.contact().id));
+      this.contactEdit.set(contact);
+
+      this.contactForm.reset();
+      this.triggerEdited.emit();
+
+    } catch (e)
+    {
+      this.notificationService.error('Erreur de recherche', "Le contact n\'existe pas !");
+
+      this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+    }
+
+    this.contactsLoading.set(false);
+  }
+}

src/app/pages/contact/contact.html

@@ -0,0 +1,11 @@
+<app-create-contact-modal (triggerCreated)="fetchCustomers()" />
+
+<div class="card">
+    <div nz-row [nzGutter]="10" style="gap: 30px">
+        @for (contact of contacts(); track contact.id)
+        {
+            <!-- Passage de la donnée du parent vers l'enfant + signal à émettre -->
+            <app-contact-card [contact]="contact" (triggerEdited)="fetchCustomers()" />
+        }
+    </div>
+</div>

src/app/pages/contact/contact.ts

@@ -0,0 +1,46 @@
+import {Component, inject, signal} from '@angular/core';
+import {ContactsService, GetContactDto} from "../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {Router} from "@angular/router";
+import {firstValueFrom} from "rxjs";
+import {CustomersCardForm} from "../customers/create-customers-modal/customers-card-form";
+import {GetAllCustomersCard} from "../customers/customers-card/get-all-customers-card";
+import {NzRowDirective} from "ng-zorro-antd/grid";
+import {CreateContactModal} from "./create-contact-modal/create-contact-modal";
+import {ContactCard} from "./contact-card/contact-card";
+
+@Component({
+  selector: 'app-contact',
+  imports: [
+    NzRowDirective,
+    CreateContactModal,
+    ContactCard
+  ],
+  templateUrl: './contact.html',
+  styleUrl: './contact.css',
+})
+export class Contact {
+  private contactsService = inject(ContactsService);
+  private notificationService = inject(NzNotificationService)
+
+  router = inject(Router);
+
+  contacts = signal<GetContactDto[]>([]);
+  contactsLoading = signal<boolean>(false);
+
+  async ngOnInit() {
+    await this.fetchCustomers();
+  }
+
+  async fetchCustomers() {
+    this.contactsLoading.set(true);
+    try {
+      const contacts = await firstValueFrom(this.contactsService.getAllContactEndpoint())
+      this.contacts.set(contacts)
+    } catch (e) {
+      this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+    }
+
+    this.contactsLoading.set(false);
+  }
+}

src/app/pages/contact/create-contact-modal/create-contact-modal.html

@@ -0,0 +1 @@
+<p>create-contact-modal works!</p>

src/app/pages/contact/create-contact-modal/create-contact-modal.ts

@@ -0,0 +1,63 @@
+import {Component, output} from '@angular/core';
+import {ContactAddForm} from "../contact-add-form/contact-add-form";
+import {NzMessageService} from "ng-zorro-antd/message";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzModalComponent} from "ng-zorro-antd/modal";
+
+@Component({
+  selector: 'app-create-contact-modal',
+  imports: [
+    ContactAddForm,
+    NzButtonComponent,
+    NzModalComponent
+  ],
+  template: `
+    <button nz-button nzType="primary" (click)="showModal()">
+      <span style="font-weight: bold">+</span>
+    </button>
+    <nz-modal
+        [(nzVisible)]="isVisible"
+        [nzTitle]="modalTitle"
+        [nzContent]="modalContent"
+        [nzFooter]="modalFooter"
+        (nzOnCancel)="handleCancel()">
+      <ng-template #modalTitle style="text-align: center">Création de contacts</ng-template>
+
+      <ng-template #modalContent>
+        <app-contact-add-form/>
+      </ng-template>
+
+      <ng-template #modalFooter>
+        <button nz-button nzType="default" (click)="handleCancel()">Annuler</button>
+        <button nz-button nzType="primary" (click)="handleOk()" [nzLoading]="isConfirmLoading">Confirmer</button>
+      </ng-template>
+    </nz-modal>
+  `,
+  styleUrl: './create-contact-modal.css',
+})
+export class CreateContactModal {
+  constructor(private message: NzMessageService) {}
+  isVisible = false;
+  isConfirmLoading = false;
+
+  showModal(): void {
+    this.isVisible = true;
+  }
+
+  handleOk(): void {
+    this.isConfirmLoading = true;
+    this.message.success('Client créé !');
+    setTimeout(() => {
+      this.isVisible = false;
+      this.isConfirmLoading = false;
+    }, 300);
+    this.triggerCreated.emit();
+  }
+
+  handleCancel(): void {
+    this.isVisible = false;
+    this.message.info('Création annulée');
+  }
+
+  triggerCreated = output<void>()
+}

src/app/pages/customers/create-customers-modal/customers-card-form.html

@@ -0,0 +1 @@
+<p>customers-card-form works!</p>

src/app/pages/customers/create-customers-modal/customers-card-form.ts

@@ -0,0 +1,59 @@
+import {Component, output} from '@angular/core';
+import {NzMessageService} from "ng-zorro-antd/message";
+import {NzButtonModule} from "ng-zorro-antd/button";
+import {NzModalModule} from "ng-zorro-antd/modal";
+import {CustomersAddForm} from "../customers-add-form/customers-add-form";
+
+@Component({
+  selector: 'app-create-customers-modal',
+    imports: [NzButtonModule, NzModalModule, CustomersAddForm],
+    template: `
+        <button nz-button nzType="primary" (click)="showModal()">
+            <span style="font-weight: bold">+</span>
+        </button>
+        <nz-modal
+                [(nzVisible)]="isVisible"
+                [nzTitle]="modalTitle"
+                [nzContent]="modalContent"
+                [nzFooter]="modalFooter"
+                (nzOnCancel)="handleCancel()">
+            <ng-template #modalTitle style="text-align: center">Création de clients</ng-template>
+
+            <ng-template #modalContent>
+                <app-customers-add-form/>
+            </ng-template>
+
+            <ng-template #modalFooter>
+                <button nz-button nzType="default" (click)="handleCancel()">Annuler</button>
+                <button nz-button nzType="primary" (click)="handleOk()" [nzLoading]="isConfirmLoading">Confirmer</button>
+            </ng-template>
+        </nz-modal>
+    `,
+  styleUrl: './customers-card-form.css',
+})
+export class CustomersCardForm {
+    constructor(private message: NzMessageService) {}
+    isVisible = false;
+    isConfirmLoading = false;
+
+    showModal(): void {
+        this.isVisible = true;
+    }
+
+    handleOk(): void {
+        this.isConfirmLoading = true;
+        this.message.success('Client créé !');
+        setTimeout(() => {
+            this.isVisible = false;
+            this.isConfirmLoading = false;
+        }, 300);
+        this.triggerCreated.emit();
+    }
+
+    handleCancel(): void {
+        this.isVisible = false;
+        this.message.info('Création annulée');
+    }
+
+    triggerCreated = output<void>()
+}

src/app/pages/customers/customers-add-form/customers-add-form.css

@@ -0,0 +1,19 @@
+nz-form-container {
+    background-color: #0000;
+}
+
+nz-form-item {
+    background-color: #1c1c1c;
+
+
+}
+
+nz-form-label {
+    font-style: italic;
+    color: #fff;
+}
+
+
+nz-modal-footer {
+
+}

src/app/pages/customers/customers-add-form/customers-add-form.html

@@ -0,0 +1,23 @@
+<form nz-form nzLayout="horizontal" [formGroup]="customerForm">
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Note</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Note" formControlName="note">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired> Type </nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <nz-select placeholder="Type de client" formControlName="customerTypeId">
+                @for (customertype of customerTypes(); track customertype.id) {
+                    <nz-option nzValue="{{customertype.id}}" nzLabel="{{ customertype.label }}"></nz-option>
+                }
+            </nz-select>
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-flex nzJustify="end">
+        <button nz-button nzType="primary" (click)="submitForm()">Valider</button>
+    </nz-flex>
+</form>

src/app/pages/customers/customers-add-form/customers-add-form.ts

@@ -0,0 +1,86 @@
+import {Component, inject, signal} from '@angular/core';
+import {FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFormModule} from "ng-zorro-antd/form";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {CreateCustomerDto, CustomersService, CustomertypesService, GetCustomerTypeDto} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+import {NzFlexDirective} from "ng-zorro-antd/flex";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzOptionComponent, NzSelectComponent} from "ng-zorro-antd/select";
+
+@Component({
+  selector: 'app-customers-add-form',
+    imports: [ReactiveFormsModule, NzFormModule, NzInputDirective, NzFlexDirective, NzButtonComponent, NzColDirective, NzFlexDirective, NzButtonComponent, NzSelectComponent, NzOptionComponent],
+  templateUrl: './customers-add-form.html',
+  styleUrl: './customers-add-form.css',
+})
+export class CustomersAddForm {
+
+    private customersService = inject(CustomersService);
+    private customertypesService = inject(CustomertypesService);
+    private notificationService = inject(NzNotificationService)
+
+
+    customerForm = new FormGroup({
+        note: new FormControl<string>(null, [Validators.required]),
+        customerTypeId: new FormControl<number>(null, [Validators.required]),
+    })
+
+    customerPost = signal<CreateCustomerDto>(this.customerForm.value);
+    customersLoading = signal<boolean>(false);
+
+    async submitForm() {
+        // Pour annuler si le formulaire est invalide
+        if (this.customerForm.invalid) return;
+
+        // Pour obtenir la valeur du formulaire
+        console.log(this.customerForm.getRawValue())
+        this.customerPost.set(this.customerForm.getRawValue())
+
+        await this.createCustomers(this.customerPost().note, this.customerPost().customerTypeId)
+        // Pour vider le formulaire
+        this.customerForm.reset()
+    }
+
+    async createCustomers(note: string, customerTypeId: number) {
+        this.customersLoading.set(true);
+
+        const customerValue = {
+            note: note,
+            customerTypeId: customerTypeId
+        }
+
+        try {
+            const customer = await firstValueFrom(this.customersService.createCustomerEndpoint(customerValue));
+            this.customerPost.set(customer);
+            console.log(customer);
+        } catch (e)
+        {
+            this.notificationService.error('Erreur de recherche', "L\'auteur n\'existe pas !");
+
+            this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+        }
+
+        this.customersLoading.set(false);
+    }
+
+    customerTypes = signal<GetCustomerTypeDto[]>([])
+
+    async ngOnInit() {
+        await this.fetchCustomerTypes()
+    }
+
+    async fetchCustomerTypes() {
+        this.customersLoading.set(true);
+        try {
+            const customerType = await firstValueFrom(this.customertypesService.getAllCustomerTypeEndpoint())
+            this.customerTypes.set(customerType)
+        } catch (e) {
+            this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+        }
+
+        this.customersLoading.set(false);
+    }
+}

src/app/pages/customers/customers-card/get-all-customers-card.html

@@ -0,0 +1,30 @@
+@if (edit() == false) {
+    <nz-card style="width:400px;" [nzActions]="[edit, delete]">
+        <h2 style="text-align: center; font-weight: bold">Client n°{{ customer().id }}</h2>
+        <p>Note : {{ customer().note }}</p>
+        <p> Type de client : {{ customer().customerType}}</p>
+    </nz-card>
+    <ng-template #edit>
+        <nz-icon (click)="Edit()" nzType="edit" nzTheme="fill" />
+    </ng-template>
+    <ng-template #delete>
+        <nz-icon (click)="Delete()" nzType="delete" nzTheme="fill" />
+    </ng-template>
+} @else {
+    <nz-card style="width:400px;" [nzActions]="[back, check]">
+        <form nz-form nzLayout="horizontal" [formGroup]="customerForm">
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Note </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Nom" formControlName="note">
+                </nz-form-control>
+            </nz-form-item>
+        </form>
+    </nz-card>
+    <ng-template #back>
+        <nz-icon (click)="Back()" nzType="backward" nzTheme="fill" />
+    </ng-template>
+    <ng-template #check>
+        <nz-icon (click)="submitForm()" nzType="check" nzTheme="outline" />
+    </ng-template>
+}

src/app/pages/customers/customers-card/get-all-customers-card.ts

@@ -0,0 +1,89 @@
+import {Component, inject, input, output, signal} from '@angular/core';
+import {NzIconDirective} from "ng-zorro-antd/icon";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzFormModule} from "ng-zorro-antd/form";
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {CustomersService, GetCustomerDto, UpdateCustomerDto} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+
+@Component({
+  selector: 'app-customers-card',
+    imports: [ReactiveFormsModule, NzFormModule, NzCardComponent, NzIconDirective, NzInputDirective],
+  templateUrl: './get-all-customers-card.html',
+  styleUrl: './get-all-customers-card.css',
+})
+export class GetAllCustomersCard {
+    private customersService = inject(CustomersService);
+    private notificationService = inject(NzNotificationService)
+
+    customerEdit = signal<UpdateCustomerDto>(null);
+    customersLoading = signal<boolean>(false);
+
+    customerForm = new FormGroup({
+        id: new FormControl(null, [Validators.required]),
+        note: new FormControl<string>(null, [Validators.required]),
+    })
+
+    async submitForm() {
+        this.customersLoading.set(true);
+
+        const customerValue = {
+            note: this.customerForm.value.note,
+        }
+
+        try {
+            const customer = await firstValueFrom(this.customersService.updateCustomer(this.customer().id,customerValue));
+            this.customerEdit.set(customer);
+            console.log(customer);
+            this.customerForm.reset();
+            this.edit.set(false);
+
+            this.triggerEdited.emit();
+
+        } catch (e)
+        {
+            this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+        }
+
+        this.customersLoading.set(false);
+
+    }
+
+
+    customer = input<GetCustomerDto>(null);
+
+    edit = signal(false)
+
+    triggerEdited = output<void>();
+
+    protected Edit() {
+        this.edit.set(true)
+    }
+
+    protected Back() {
+        this.edit.set(false)
+        this.customerForm.reset();
+    }
+
+    async Delete() {
+        this.customersLoading.set(true);
+
+        try {
+            const customer = await firstValueFrom(this.customersService.deleteCustomerEndpoint(this.customer().id));
+            this.customerEdit.set(customer);
+
+            this.customerForm.reset();
+            this.triggerEdited.emit();
+
+        } catch (e)
+        {
+            this.notificationService.error('Erreur de recherche', "L\'auteur n\'existe pas !");
+
+            this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+        }
+
+        this.customersLoading.set(false);
+    }
+}

src/app/pages/customers/customers.html

@@ -1 +1,11 @@
-<p>customers works!</p>
+<app-create-customers-modal (triggerCreated)="fetchCustomers()" />
+
+<div class="card">
+    <div nz-row [nzGutter]="10" style="gap: 30px">
+        @for (customer of customers(); track customer.id)
+        {
+            <!-- Passage de la donnée du parent vers l'enfant + signal à émettre -->
+            <app-customers-card [customer]="customer" (triggerEdited)="fetchCustomers()" />
+        }
+    </div>
+</div>

src/app/pages/customers/customers.ts

@@ -1,11 +1,44 @@
-import { Component } from '@angular/core';
+import {Component, inject, signal} from '@angular/core';
+import {CustomersCardForm} from "./create-customers-modal/customers-card-form";
+import {GetAllCustomersCard} from "./customers-card/get-all-customers-card";
+import {NzRowDirective} from "ng-zorro-antd/grid";
+import {CustomersService, GetCustomerDto} from "../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {Router} from "@angular/router";
+import {firstValueFrom} from "rxjs";
 
 @Component({
   selector: 'app-customers',
-  imports: [],
+    imports: [
+        CustomersCardForm,
+        GetAllCustomersCard,
+        NzRowDirective
+    ],
   templateUrl: './customers.html',
   styleUrl: './customers.css',
 })
 export class Customers {
+    private customersService = inject(CustomersService);
+    private notificationService = inject(NzNotificationService)
 
-}
+    router = inject(Router);
+
+    customers = signal<GetCustomerDto[]>([]);
+    customersLoading = signal<boolean>(false);
+
+    async ngOnInit() {
+        await this.fetchCustomers();
+    }
+
+    async fetchCustomers() {
+        this.customersLoading.set(true);
+        try {
+            const customers = await firstValueFrom(this.customersService.getAllCustomerEndpoint())
+            this.customers.set(customers)
+        } catch (e) {
+            this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+        }
+
+        this.customersLoading.set(false);
+    }
+}

src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.html

@@ -0,0 +1 @@
+<p>create-opportunity-modal works!</p>

src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.ts

@@ -0,0 +1,63 @@
+import {Component, output} from '@angular/core';
+import {OpportunityAddForm} from "../opportunity-add-form/opportunity-add-form";
+import {NzMessageService} from "ng-zorro-antd/message";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzModalComponent} from "ng-zorro-antd/modal";
+
+@Component({
+  selector: 'app-create-opportunity-modal',
+  imports: [
+    OpportunityAddForm,
+    NzButtonComponent,
+    NzModalComponent
+  ],
+  template: `
+        <button nz-button nzType="primary" (click)="showModal()">
+            <span style="font-weight: bold">+</span>
+        </button>
+        <nz-modal
+                [(nzVisible)]="isVisible"
+                [nzTitle]="modalTitle"
+                [nzContent]="modalContent"
+                [nzFooter]="modalFooter"
+                (nzOnCancel)="handleCancel()">
+            <ng-template #modalTitle style="text-align: center">Création d'opportunités</ng-template>
+
+            <ng-template #modalContent>
+                <app-opportunity-add-form/>
+            </ng-template>
+
+            <ng-template #modalFooter>
+                <button nz-button nzType="default" (click)="handleCancel()">Annuler</button>
+                <button nz-button nzType="primary" (click)="handleOk()" [nzLoading]="isConfirmLoading">Confirmer</button>
+            </ng-template>
+        </nz-modal>
+    `,
+  styleUrl: './create-opportunity-modal.css',
+})
+export class CreateOpportunityModal {
+    constructor(private message: NzMessageService) {}
+    isVisible = false;
+    isConfirmLoading = false;
+
+    showModal(): void {
+      this.isVisible = true;
+    }
+
+    handleOk(): void {
+      this.isConfirmLoading = true;
+      this.message.success('Opportunité créé !');
+      setTimeout(() => {
+        this.isVisible = false;
+        this.isConfirmLoading = false;
+      }, 300);
+      this.triggerCreated.emit();
+    }
+
+    handleCancel(): void {
+      this.isVisible = false;
+      this.message.info('Création annulée');
+    }
+
+    triggerCreated = output<void>()
+}

src/app/pages/opportunities/opportunities.html

@@ -1 +1,57 @@
-<p>opportunities works!</p>
+<app-create-opportunity-modal (triggerCreated)="fetchCommunications()" />
+
+<nz-divider></nz-divider>
+
+<nz-card style="margin-bottom: 16px">
+    <div nz-row [nzGutter]="16" style="text-align: center">
+        <div nz-col [nzSpan]="8">
+            <h3>📞 Appels</h3>
+            <p style="font-size: 24px; font-weight: bold">{{ totalCalls }}</p>
+        </div>
+        <div nz-col [nzSpan]="8">
+            <h3>✉️ Emails</h3>
+            <p style="font-size: 24px; font-weight: bold">{{ totalEmails }}</p>
+        </div>
+        <div nz-col [nzSpan]="8">
+            <h3>🤝 Réunions</h3>
+            <p style="font-size: 24px; font-weight: bold">{{ totalMeetings }}</p>
+        </div>
+    </div>
+</nz-card>
+
+<nz-divider></nz-divider>
+
+<div nz-row [nzGutter]="16">
+    <div nz-col [nzSpan]="8">
+        <nz-card nzTitle="Appels ({{ totalCalls }})">
+            @for (communication of communications(); track communication.id) {
+                @if (communication.calling) {
+                    <app-opportunity-card [communication]="communication" (triggerEdited)="fetchCommunications()" />
+                    <nz-divider></nz-divider>
+                }
+            }
+        </nz-card>
+    </div>
+
+    <div nz-col [nzSpan]="8">
+        <nz-card nzTitle="Emails ({{ totalEmails }})">
+            @for (communication of communications(); track communication.id) {
+                @if (communication.email) {
+                    <app-opportunity-card [communication]="communication" (triggerEdited)="fetchCommunications()" />
+                    <nz-divider></nz-divider>
+                }
+            }
+        </nz-card>
+    </div>
+
+    <div nz-col [nzSpan]="8">
+        <nz-card nzTitle="Réunions ({{ totalMeetings }})">
+            @for (communication of communications(); track communication.id) {
+                @if (communication.meeting) {
+                    <app-opportunity-card [communication]="communication" (triggerEdited)="fetchCommunications()" />
+                    <nz-divider></nz-divider>
+                }
+            }
+        </nz-card>
+    </div>
+</div>

src/app/pages/opportunities/opportunities.ts

@@ -1,11 +1,54 @@
-import { Component } from '@angular/core';
+import {Component, inject, signal} from '@angular/core';
+import {CreateOpportunityModal} from "./create-opportunity-modal/create-opportunity-modal";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {Router} from "@angular/router";
+import {firstValueFrom} from "rxjs";
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzDividerComponent} from "ng-zorro-antd/divider";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {OpportunityCard} from "./opportunity-card/opportunity-card";
+import {CommunicationsService, GetCommunicationDto} from "../../services/api";
 
 @Component({
   selector: 'app-opportunities',
-  imports: [],
+  imports: [CreateOpportunityModal, NzCardComponent, NzDividerComponent, NzRowDirective, NzColDirective, OpportunityCard],
   templateUrl: './opportunities.html',
   styleUrl: './opportunities.css',
 })
 export class Opportunities {
+  private communicationsService = inject(CommunicationsService);
+  private notificationService = inject(NzNotificationService)
 
+  router = inject(Router);
+
+  communications = signal<GetCommunicationDto[]>([]);
+  communicationsLoading = signal<boolean>(false);
+
+  async ngOnInit() {
+    await this.fetchCommunications();
+  }
+
+  get totalCalls() {
+    return this.communications().filter(c => c.calling).length;
+  }
+
+  get totalEmails() {
+    return this.communications().filter(c => c.email).length;
+  }
+
+  get totalMeetings() {
+    return this.communications().filter(c => c.meeting).length;
+  }
+
+  async fetchCommunications() {
+    this.communicationsLoading.set(true);
+    try {
+      const communications = await firstValueFrom(this.communicationsService.getAllCommunicationsEndpoint())
+      this.communications.set(communications)
+    } catch (e) {
+      this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+    }
+
+    this.communicationsLoading.set(false);
+  }
 }

src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.html

@@ -0,0 +1,37 @@
+<form nz-form nzLayout="horizontal" [formGroup]="communicationForm">
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Appel</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Appel" formControlName="calling">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Email</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Email" formControlName="email">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Réunion</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Réunion" formControlName="meeting">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Contact</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <nz-select placeholder="Sélectionner un contact" formControlName="contactId">
+                @for (contact of contacts(); track contact.id) {
+                    <nz-option [nzValue]="contact.id" nzLabel="{{ contact.firstName }} {{ contact.lastName }}"></nz-option>
+                }
+            </nz-select>
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-flex nzJustify="end">
+        <button nz-button nzType="primary" (click)="submitForm()">Valider</button>
+    </nz-flex>
+</form>

src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.ts

@@ -0,0 +1,105 @@
+import {Component, inject, signal} from '@angular/core';
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFlexDirective} from "ng-zorro-antd/flex";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {CommunicationsService, ContactsService, CreateCommunicationDto, GetContactDto} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+import {NzOptionComponent, NzSelectComponent} from "ng-zorro-antd/select";
+
+@Component({
+  selector: 'app-opportunity-add-form',
+  imports: [
+    NzButtonComponent,
+    NzColDirective,
+    NzFlexDirective,
+    NzFormControlComponent,
+    NzFormDirective,
+    NzFormItemComponent,
+    NzFormLabelComponent,
+    NzInputDirective,
+    NzRowDirective,
+    ReactiveFormsModule,
+    NzSelectComponent,
+    NzOptionComponent
+  ],
+  templateUrl: './opportunity-add-form.html',
+  styleUrl: './opportunity-add-form.css',
+})
+export class OpportunityAddForm {
+
+    private communicationsService = inject(CommunicationsService);
+    private notificationService = inject(NzNotificationService)
+    private contactsService = inject(ContactsService);
+
+
+    communicationForm = new FormGroup({
+      calling: new FormControl<string>(null),
+      email: new FormControl<string>(null),
+      meeting: new FormControl<string>(null),
+      contactId: new FormControl<number>(null, [Validators.required]),
+    }, { validators: atLeastOneRequired })
+
+    communicationPost = signal<CreateCommunicationDto>(this.communicationForm.value);
+    communicationsLoading = signal<boolean>(false);
+
+    async submitForm() {
+      if (this.communicationForm.invalid) return;
+
+      const raw = this.communicationForm.getRawValue();
+      console.log('contactId:', raw.contactId, 'type:', typeof raw.contactId);
+
+      console.log(this.communicationForm.getRawValue())
+      this.communicationPost.set(this.communicationForm.getRawValue())
+
+      await this.createCommunication(this.communicationPost().calling, this.communicationPost().email, this.communicationPost().meeting, this.communicationPost().contactId)
+      this.communicationForm.reset()
+    }
+
+    async createCommunication(calling: string, email: string, meeting: string, contactId: number) {
+      this.communicationsLoading.set(true);
+
+      const communicationValue: CreateCommunicationDto = {
+        calling: calling,
+        email: email,
+        meeting: meeting,
+        contactId: Number(contactId)
+      }
+
+      try {
+        const communication = await firstValueFrom(this.communicationsService.createCommunicationEndpoint(communicationValue));
+        this.communicationPost.set(communication);
+        console.log(communication);
+      } catch (e) {
+        this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+      }
+
+      this.communicationsLoading.set(false);
+    }
+
+    contacts = signal<GetContactDto[]>([]);
+
+    async ngOnInit() {
+      await this.fetchContacts();
+    }
+
+    async fetchContacts() {
+      try {
+        const contacts = await firstValueFrom(this.contactsService.getAllContactEndpoint());
+        this.contacts.set(contacts);
+      } catch (e) {
+        this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+      }
+    }
+  }
+
+
+
+  function atLeastOneRequired(group: FormGroup) {
+    const { calling, email, meeting } = group.controls;
+    const valid = [calling, email, meeting].some(c => c.value);
+    return valid ? null : { atLeastOneRequired: true };
+  }

src/app/pages/opportunities/opportunity-card/opportunity-card.html

@@ -0,0 +1,58 @@
+@if (edit() == false) {
+    <nz-card style="width:400px;" [nzActions]="[edit, delete]">
+        <h2 style="text-align: center; font-weight: bold">Contact n°{{ communication().contactId }}</h2>
+        @if (communication().calling) {
+            <p>📞 Appel : {{ communication().calling }}</p>
+            <p> Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}</p>
+            <p> Numéro du Contact : {{ communication().contactPhoneNumber }}</p>
+            <p> Email du Contact : {{ communication().contactEmail }}</p>
+        }
+        @if (communication().email) {
+            <p>✉️ Email : {{ communication().email }}</p>
+            <p> Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}</p>
+            <p> Numéro du Contact : {{ communication().contactPhoneNumber }}</p>
+            <p> Email du Contact : {{ communication().contactEmail }}</p>
+        }
+        @if (communication().meeting) {
+            <p>🤝 Réunion : {{ communication().meeting }}</p>
+            <p> Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}</p>
+            <p> Numéro du Contact : {{ communication().contactPhoneNumber }}</p>
+            <p> Email du Contact : {{ communication().contactEmail }}</p>
+        }
+    </nz-card>
+    <ng-template #edit>
+        <nz-icon (click)="Edit()" nzType="edit" nzTheme="fill" />
+    </ng-template>
+    <ng-template #delete>
+        <nz-icon (click)="Delete()" nzType="delete" nzTheme="fill" />
+    </ng-template>
+} @else {
+    <nz-card style="width:400px;" [nzActions]="[back, check]">
+        <form nz-form nzLayout="horizontal" [formGroup]="communicationForm">
+            <nz-form-item>
+                <nz-form-label nzSpan="5">Appel</nz-form-label>
+                <nz-form-control nzSpan="22">
+                    <input nz-input placeholder="Appel" formControlName="calling">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5">Email</nz-form-label>
+                <nz-form-control nzSpan="22">
+                    <input nz-input placeholder="Email" formControlName="email">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5">Réunion</nz-form-label>
+                <nz-form-control nzSpan="22">
+                    <input nz-input placeholder="Réunion" formControlName="meeting">
+                </nz-form-control>
+            </nz-form-item>
+        </form>
+    </nz-card>
+    <ng-template #back>
+        <nz-icon (click)="Back()" nzType="backward" nzTheme="fill" />
+    </ng-template>
+    <ng-template #check>
+        <nz-icon (click)="submitForm()" nzType="check" nzTheme="outline" />
+    </ng-template>
+}

src/app/pages/opportunities/opportunity-card/opportunity-card.ts

@@ -0,0 +1,100 @@
+import {Component, inject, input, output, signal} from '@angular/core';
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {FormControl, FormGroup, ReactiveFormsModule} from "@angular/forms";
+import {firstValueFrom} from "rxjs";
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzFormControlComponent, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzIconDirective} from "ng-zorro-antd/icon";
+import {NzColDirective} from "ng-zorro-antd/grid";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {CommunicationsService, GetCommunicationDto, UpdateCommunicationDto} from "../../../services/api";
+
+@Component({
+  selector: 'app-opportunity-card',
+  imports: [
+    NzCardComponent,
+    ReactiveFormsModule,
+    NzFormLabelComponent,
+    NzFormControlComponent,
+    NzFormItemComponent,
+    NzIconDirective,
+    NzColDirective,
+    NzInputDirective
+  ],
+  templateUrl: './opportunity-card.html',
+  styleUrl: './opportunity-card.css',
+})
+export class OpportunityCard {
+    private communicationsService = inject(CommunicationsService);
+    private notificationService = inject(NzNotificationService);
+
+    communicationEdit = signal<UpdateCommunicationDto>(null);
+    communicationsLoading = signal<boolean>(false);
+
+    communicationForm = new FormGroup({
+      calling: new FormControl<string>(null),
+      email: new FormControl<string>(null),
+      meeting: new FormControl<string>(null),
+    }, { validators: atLeastOneRequired })
+
+    async submitForm() {
+      this.communicationsLoading.set(true);
+
+      const communicationValue: UpdateCommunicationDto = {
+        calling: this.communicationForm.value.calling,
+        email: this.communicationForm.value.email,
+        meeting: this.communicationForm.value.meeting,
+      }
+
+      try {
+        const communication = await firstValueFrom(this.communicationsService.updateCommunicationEndpoint(this.communication().id, communicationValue));
+        this.communicationEdit.set(communication as unknown as UpdateCommunicationDto);
+        console.log(communication);
+        this.communicationForm.reset();
+        this.edit.set(false);
+        this.triggerEdited.emit();
+      } catch (e) {
+        this.notificationService.error('Erreur', '(ou Erreur de communication avec l\'API)');
+      }
+
+      this.communicationsLoading.set(false);
+    }
+
+    communication = input<GetCommunicationDto>(null);
+    edit = signal(false);
+    triggerEdited = output<void>();
+
+    protected Edit() {
+      this.edit.set(true);
+      this.communicationForm.patchValue({
+        calling: this.communication().calling,
+        email: this.communication().email,
+        meeting: this.communication().meeting,
+      });
+    }
+
+    protected Back() {
+      this.edit.set(false);
+      this.communicationForm.reset();
+    }
+
+    async Delete() {
+      this.communicationsLoading.set(true);
+
+      try {
+        await firstValueFrom(this.communicationsService.deleteCommunicationEndpoint(this.communication().id));
+        this.communicationForm.reset();
+        this.triggerEdited.emit();
+      } catch (e) {
+        this.notificationService.error('Erreur', '(ou Erreur de communication avec l\'API)');
+      }
+
+      this.communicationsLoading.set(false);
+    }
+  }
+
+  function atLeastOneRequired(group: FormGroup) {
+    const { calling, email, meeting } = group.controls;
+    const valid = [calling, email, meeting].some(c => c.value);
+    return valid ? null : { atLeastOneRequired: true };
+}

src/app/pages/providers/create-providers-modal/create-providers-modal.html

@@ -0,0 +1 @@
+<p>create-providers-modal works!</p>

src/app/pages/providers/create-providers-modal/create-providers-modal.ts

@@ -0,0 +1,59 @@
+import {Component, output} from '@angular/core';
+import {NzMessageService} from "ng-zorro-antd/message";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzModalComponent} from "ng-zorro-antd/modal";
+import {ProvidersAddForm} from "../providers-add-form/providers-add-form";
+
+@Component({
+  selector: 'app-create-providers-modal',
+  imports: [NzButtonComponent, NzModalComponent, ProvidersAddForm],
+  template: `
+    <button nz-button nzType="primary" (click)="showModal()">
+      <span style="font-weight: bold">+</span>
+    </button>
+    <nz-modal
+        [(nzVisible)]="isVisible"
+        [nzTitle]="modalTitle"
+        [nzContent]="modalContent"
+        [nzFooter]="modalFooter"
+        (nzOnCancel)="handleCancel()">
+      <ng-template #modalTitle style="text-align: center">Création de prestataires</ng-template>
+
+      <ng-template #modalContent>
+        <app-providers-add-form/>
+      </ng-template>
+
+      <ng-template #modalFooter>
+        <button nz-button nzType="default" (click)="handleCancel()">Annuler</button>
+        <button nz-button nzType="primary" (click)="handleOk()" [nzLoading]="isConfirmLoading">Confirmer</button>
+      </ng-template>
+    </nz-modal>
+  `,
+  styleUrl: './create-providers-modal.css',
+})
+export class CreateProvidersModal {
+    constructor(private message: NzMessageService) {}
+    isVisible = false;
+    isConfirmLoading = false;
+
+    showModal(): void {
+      this.isVisible = true;
+    }
+
+    handleOk(): void {
+      this.isConfirmLoading = true;
+      this.message.success('Prestataire créé !');
+      setTimeout(() => {
+        this.isVisible = false;
+        this.isConfirmLoading = false;
+      }, 300);
+      this.triggerCreated.emit();
+    }
+
+    handleCancel(): void {
+      this.isVisible = false;
+      this.message.info('Création annulée');
+    }
+
+    triggerCreated = output<void>()
+}

src/app/pages/providers/providers-add-form/providers-add-form.html

@@ -0,0 +1,23 @@
+<form nz-form nzLayout="horizontal" [formGroup]="providerForm">
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Prix</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Prix" formControlName="price">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired> Type </nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <nz-select placeholder="Type de client" formControlName="providerTypeId">
+                @for (providertype of providerTypes(); track providertype.id) {
+                    <nz-option nzValue="{{providertype.id}}" nzLabel="{{ providertype.label }}"></nz-option>
+                }
+            </nz-select>
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-flex nzJustify="end">
+        <button nz-button nzType="primary" (click)="submitForm()">Valider</button>
+    </nz-flex>
+</form>

src/app/pages/providers/providers-add-form/providers-add-form.ts

@@ -0,0 +1,85 @@
+import {Component, inject, signal} from '@angular/core';
+import {FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFlexDirective} from "ng-zorro-antd/flex";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {NzOptionComponent, NzSelectComponent} from "ng-zorro-antd/select";
+import {CreateProviderDto, GetProviderTypeDto, ProvidertypesService, ServiceprovidersService} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+
+@Component({
+  selector: 'app-providers-add-form',
+  imports: [FormsModule, NzButtonComponent, NzColDirective, NzFlexDirective, NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent, NzInputDirective, NzOptionComponent, NzRowDirective, NzSelectComponent, ReactiveFormsModule],
+  templateUrl: './providers-add-form.html',
+  styleUrl: './providers-add-form.css',
+})
+export class ProvidersAddForm {
+  private providersService = inject(ServiceprovidersService);
+  private serviceprovidertypesService = inject(ProvidertypesService);
+  private notificationService = inject(NzNotificationService)
+
+
+  providerForm = new FormGroup({
+    Price: new FormControl<number>(null, [Validators.required]),
+    providerTypeId: new FormControl<number>(null, [Validators.required]),
+  })
+
+  providerPost = signal<CreateProviderDto>(this.providerForm.value);
+  providersLoading = signal<boolean>(false);
+
+  async submitForm() {
+    // Pour annuler si le formulaire est invalide
+    if (this.providerForm.invalid) return;
+
+    // Pour obtenir la valeur du formulaire
+    console.log(this.providerForm.getRawValue())
+    this.providerPost.set(this.providerForm.getRawValue())
+
+    await this.createProviders(this.providerPost().price, this.providerPost().providerTypeId)
+    // Pour vider le formulaire
+    this.providerForm.reset()
+  }
+
+  async createProviders(price: number, customerTypeId: number) {
+    this.providersLoading.set(true);
+
+    const providerValue = {
+      price: price,
+      customerTypeId: customerTypeId
+    }
+
+    try {
+      const provider = await firstValueFrom(this.providersService.createProviderEndpoint(providerValue));
+      this.providerPost.set(provider);
+      console.log(provider);
+    } catch (e)
+    {
+      this.notificationService.error('Erreur de recherche', "L\'auteur n\'existe pas !");
+
+      this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+    }
+
+    this.providersLoading.set(false);
+  }
+
+  providerTypes = signal<GetProviderTypeDto[]>([])
+
+  async ngOnInit() {
+    await this.fetchCustomerTypes()
+  }
+
+  async fetchCustomerTypes() {
+    this.providersLoading.set(true);
+    try {
+      const providerType = await firstValueFrom(this.serviceprovidertypesService.getAllProviderTypesEndpoint())
+      this.providerTypes.set(providerType)
+    } catch (e) {
+      this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+    }
+
+    this.providersLoading.set(false);
+  }
+}

src/app/pages/providers/providers-card/providers-card.html

@@ -0,0 +1,30 @@
+@if (edit() == false) {
+    <nz-card style="width:400px;" [nzActions]="[edit, delete]">
+        <h2 style="text-align: center; font-weight: bold">Prestataire n°{{ provider().id }}</h2>
+        <p>Prix : {{ provider().price }}</p>
+        <p>Type de Prestataire : {{ provider().providerType }}</p>
+    </nz-card>
+    <ng-template #edit>
+        <nz-icon (click)="Edit()" nzType="edit" nzTheme="fill" />
+    </ng-template>
+    <ng-template #delete>
+        <nz-icon (click)="Delete()" nzType="delete" nzTheme="fill" />
+    </ng-template>
+} @else {
+    <nz-card style="width:400px;" [nzActions]="[back, check]">
+        <form nz-form nzLayout="horizontal" [formGroup]="providerForm">
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Prix </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Nom" formControlName="price">
+                </nz-form-control>
+            </nz-form-item>
+        </form>
+    </nz-card>
+    <ng-template #back>
+        <nz-icon (click)="Back()" nzType="backward" nzTheme="fill" />
+    </ng-template>
+    <ng-template #check>
+        <nz-icon (click)="submitForm()" nzType="check" nzTheme="outline" />
+    </ng-template>
+}

src/app/pages/providers/providers-card/providers-card.ts

@@ -0,0 +1,90 @@
+import {Component, inject, input, output, signal} from '@angular/core';
+import {FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzIconDirective} from "ng-zorro-antd/icon";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {GetProviderDto, ServiceprovidersService, UpdateProviderDto} from "../../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+
+@Component({
+  selector: 'app-providers-card',
+  imports: [FormsModule, NzCardComponent, NzColDirective, NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent, NzIconDirective, NzInputDirective, NzRowDirective, ReactiveFormsModule],
+  templateUrl: './providers-card.html',
+  styleUrl: './providers-card.css',
+})
+export class ProvidersCard {
+    private providersService = inject(ServiceprovidersService);
+    private notificationService = inject(NzNotificationService)
+
+    providerEdit = signal<UpdateProviderDto>(null);
+    providersLoading = signal<boolean>(false);
+
+    providerForm = new FormGroup({
+      id: new FormControl(null, [Validators.required]),
+      price: new FormControl<number>(null, [Validators.required]),
+    })
+
+    async submitForm() {
+      this.providersLoading.set(true);
+
+      const providerValue = {
+        price: this.providerForm.value.price,
+      }
+
+      try {
+        const provider = await firstValueFrom(this.providersService.updateProviderEndpoint(this.provider().id,providerValue));
+        this.providerEdit.set(provider);
+        console.log(provider);
+        this.providerForm.reset();
+        this.edit.set(false);
+
+        this.triggerEdited.emit();
+
+      } catch (e)
+      {
+        this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+      }
+
+      this.providersLoading.set(false);
+
+    }
+
+
+    provider = input<GetProviderDto>(null);
+
+    edit = signal(false)
+
+    triggerEdited = output<void>();
+
+    protected Edit() {
+      this.edit.set(true)
+    }
+
+    protected Back() {
+      this.edit.set(false)
+      this.providerForm.reset();
+    }
+
+    async Delete() {
+      this.providersLoading.set(true);
+
+      try {
+        const provider = await firstValueFrom(this.providersService.deleteProviderEndpoint(this.provider().id));
+        this.providerEdit.set(provider);
+
+        this.providerForm.reset();
+        this.triggerEdited.emit();
+
+      } catch (e)
+      {
+        this.notificationService.error('Erreur de recherche', "L\'auteur n\'existe pas !");
+
+        this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+      }
+
+      this.providersLoading.set(false);
+    }
+}

src/app/pages/providers/providers.html

@@ -1 +1,11 @@
-<p>providers works!</p>
+<app-create-providers-modal (triggerCreated)="fetchProviders()" />
+
+<div class="card">
+    <div nz-row [nzGutter]="10" style="gap: 30px">
+        @for (provider of providers(); track provider.id)
+        {
+            <!-- Passage de la donnée du parent vers l'enfant + signal à émettre -->
+            <app-providers-card [provider]="provider" (triggerEdited)="fetchProviders()" />
+        }
+    </div>
+</div>

src/app/pages/providers/providers.ts

@@ -1,11 +1,40 @@
-import { Component } from '@angular/core';
+import {Component, inject, signal} from '@angular/core';
+import {NzRowDirective} from "ng-zorro-antd/grid";
+import {GetProviderDto, ServiceprovidersService} from "../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {Router} from "@angular/router";
+import {firstValueFrom} from "rxjs";
+import {ProvidersCard} from "./providers-card/providers-card";
+import {CreateProvidersModal} from "./create-providers-modal/create-providers-modal";
 
 @Component({
   selector: 'app-providers',
-  imports: [],
+    imports: [NzRowDirective, ProvidersCard, CreateProvidersModal],
   templateUrl: './providers.html',
   styleUrl: './providers.css',
 })
 export class Providers {
+    private providersService = inject(ServiceprovidersService);
+    private notificationService = inject(NzNotificationService)
 
+    router = inject(Router);
+
+    providers = signal<GetProviderDto[]>([]);
+    providersLoading = signal<boolean>(false);
+
+    async ngOnInit() {
+        await this.fetchProviders();
+    }
+
+    async fetchProviders() {
+        this.providersLoading.set(true);
+        try {
+            const providers = await firstValueFrom(this.providersService.getAllProvidersEndpoint())
+            this.providers.set(providers)
+        } catch (e) {
+            this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+        }
+
+        this.providersLoading.set(false);
+    }
 }

src/app/pages/staff/create-staff-modal/create-staff-modal.html

@@ -0,0 +1 @@
+<p>create-staff-modal works!</p>

src/app/pages/staff/create-staff-modal/create-staff-modal.ts

@@ -0,0 +1,63 @@
+import {Component, output} from '@angular/core';
+import StaffAddForm from "../staff-add-form/staff-add-form";
+import {NzMessageService} from "ng-zorro-antd/message";
+import {NzModalComponent} from "ng-zorro-antd/modal";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+
+@Component({
+  selector: 'app-create-staff-modal',
+  imports: [
+    StaffAddForm,
+    NzModalComponent,
+    NzButtonComponent
+  ],
+  template: `
+    <button nz-button nzType="primary" (click)="showModal()">
+      <span style="font-weight: bold">+</span>
+    </button>
+    <nz-modal
+        [(nzVisible)]="isVisible"
+        [nzTitle]="modalTitle"
+        [nzContent]="modalContent"
+        [nzFooter]="modalFooter"
+        (nzOnCancel)="handleCancel()">
+      <ng-template #modalTitle style="text-align: center">Création de staff</ng-template>
+
+      <ng-template #modalContent>
+        <app-staff-add-form/>
+      </ng-template>
+
+      <ng-template #modalFooter>
+        <button nz-button nzType="default" (click)="handleCancel()">Annuler</button>
+        <button nz-button nzType="primary" (click)="handleOk()" [nzLoading]="isConfirmLoading">Confirmer</button>
+      </ng-template>
+    </nz-modal>
+  `,
+  styleUrl: './create-staff-modal.css',
+})
+export class CreateStaffModal {
+  constructor(private message: NzMessageService) {}
+  isVisible = false;
+  isConfirmLoading = false;
+
+  showModal(): void {
+    this.isVisible = true;
+  }
+
+  handleOk(): void {
+    this.isConfirmLoading = true;
+    this.message.success('Staff créé !');
+    setTimeout(() => {
+      this.isVisible = false;
+      this.isConfirmLoading = false;
+    }, 300);
+    this.triggerCreated.emit();
+  }
+
+  handleCancel(): void {
+    this.isVisible = false;
+    this.message.info('Création annulée');
+  }
+
+  triggerCreated = output<void>()
+}

src/app/pages/staff/staff-add-form/staff-add-form.html

@@ -0,0 +1,47 @@
+<form nz-form nzLayout="horizontal" [formGroup]="staffForm">
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Nom</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Nom de Famille" formControlName="lastName">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Prénom</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Prénom" formControlName="firstName">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Profession</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Profession" formControlName="profession">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Email</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Email" formControlName="email">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Numéro F4T2</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Numéro F4T2" formControlName="f4T2NumberApproval">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-form-item>
+        <nz-form-label nzSpan="5" nzRequired>Exp. F4T2</nz-form-label>
+        <nz-form-control nzErrorTip="Ce champ est requis">
+            <input nz-input placeholder="Date d'expiration F4T2" formControlName="f4T2ExpirationDate">
+        </nz-form-control>
+    </nz-form-item>
+
+    <nz-flex nzJustify="end">
+        <button nz-button nzType="primary" (click)="submitForm()">Valider</button>
+    </nz-flex>
+</form>

src/app/pages/staff/staff-add-form/staff-add-form.ts

@@ -0,0 +1,94 @@
+import {Component, inject, signal} from '@angular/core';
+import {FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzButtonComponent} from "ng-zorro-antd/button";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFlexDirective} from "ng-zorro-antd/flex";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+import {CreateStaffDto, GetProviderTypeDto, ProvidertypesService, StaffsService} from "../../../services/api";
+
+@Component({
+  selector: 'app-staff-add-form',
+  imports: [FormsModule, NzButtonComponent, NzColDirective, NzFlexDirective, NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent, NzInputDirective, NzRowDirective, ReactiveFormsModule],
+  templateUrl: './staff-add-form.html',
+  styleUrl: './staff-add-form.css',
+})
+class StaffAddForm {
+    private staffsService = inject(StaffsService);
+    private serviceprovidertypesService = inject(ProvidertypesService);
+    private notificationService = inject(NzNotificationService)
+
+
+    staffForm = new FormGroup({
+        lastName: new FormControl<string>(null, [Validators.required]),
+        firstName: new FormControl<string>(null, [Validators.required]),
+        profession: new FormControl<string>(null, [Validators.required]),
+        email: new FormControl<string>(null, [Validators.required]),
+        f4T2NumberApproval: new FormControl<string>(null, [Validators.required]),
+        f4T2ExpirationDate: new FormControl<Date>(null, [Validators.required])
+    })
+
+    staffPost = signal<CreateStaffDto>(this.staffForm.value as any);
+    staffsLoading = signal<boolean>(false);
+
+    async submitForm() {
+      // Pour annuler si le formulaire est invalide
+      if (this.staffForm.invalid) return;
+
+      // Pour obtenir la valeur du formulaire
+      console.log(this.staffForm.getRawValue())
+      this.staffPost.set(this.staffForm.getRawValue() as any)
+
+      await this.createStaff(this.staffPost().lastName, this.staffPost().firstName, this.staffPost().profession, this.staffPost().email, this.staffPost().f4T2NumberApproval, this.staffPost().f4T2ExpirationDate)
+      // Pour vider le formulaire
+      this.staffForm.reset()
+    }
+
+    async createStaff(lastname: string, firstname: string, profession: string, email: string, f4t2number: string, f4t2expiration: Date | string)
+    {
+      this.staffsLoading.set(true);
+
+        const staffValue: CreateStaffDto = {
+            lastName: lastname,
+            firstName: firstname,
+            profession: profession,
+            email: email,
+            f4T2NumberApproval: f4t2number,
+            f4T2ExpirationDate: f4t2expiration instanceof Date ? f4t2expiration : new Date(f4t2expiration)
+        }
+
+      try {
+        const staff = await firstValueFrom(this.staffsService.createStaffEndpoint(staffValue));
+          this.staffPost.set(staff as unknown as CreateStaffDto);
+        console.log(staff);
+      } catch (e)
+      {
+
+        this.notificationService.error('Erreur', ' (ou Erreur de communication avec l\'API)');
+      }
+
+      this.staffsLoading.set(false);
+    }
+
+    providerTypes = signal<GetProviderTypeDto[]>([])
+
+    async ngOnInit() {
+      await this.fetchCustomerTypes()
+    }
+
+    async fetchCustomerTypes() {
+      this.staffsLoading.set(true);
+      try {
+        const providerType = await firstValueFrom(this.serviceprovidertypesService.getAllProviderTypesEndpoint())
+        this.providerTypes.set(providerType)
+      } catch (e) {
+        this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+      }
+
+      this.staffsLoading.set(false);
+    }
+}
+
+export default StaffAddForm

src/app/pages/staff/staff-card/staff-card.html

@@ -0,0 +1,40 @@
+@if (edit() == false) {
+    <nz-card style="width:400px;" [nzActions]="[edit, delete]">
+        <h2 style="text-align: center; font-weight: bold">Staff n°{{ staff().id }}</h2>
+        <p>Nom : {{ staff().lastName }} {{ staff().firstName }}</p>
+        <p>Profession : {{ staff().profession }}</p>
+        <p>Email : {{ staff().email }}</p>
+        <p>N° F4T2 : {{ staff().f4T2NumberApproval }}</p>
+        <p>Expiration F4T2 : {{ staff().f4T2ExpirationDate }}</p>
+        <p> Niveau d'experience : {{ staff().experienceLevel}}</p>
+    </nz-card>
+    <ng-template #edit>
+        <nz-icon (click)="Edit()" nzType="edit" nzTheme="fill" />
+    </ng-template>
+    <ng-template #delete>
+        <nz-icon (click)="Delete()" nzType="delete" nzTheme="fill" />
+    </ng-template>
+} @else {
+    <nz-card style="width:400px;" [nzActions]="[back, check]">
+        <form nz-form nzLayout="horizontal" [formGroup]="staffForm">
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> N° F4T2 </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="N° F4T2" formControlName="f4T2NumberApproval">
+                </nz-form-control>
+            </nz-form-item>
+            <nz-form-item>
+                <nz-form-label nzSpan="5" nzRequired> Exp. F4T2 </nz-form-label>
+                <nz-form-control nzSpan="22" nzErrorTip="Ce champ est requis !">
+                    <input nz-input placeholder="Expiration F4T2" formControlName="f4T2ExpirationDate">
+                </nz-form-control>
+            </nz-form-item>
+        </form>
+    </nz-card>
+    <ng-template #back>
+        <nz-icon (click)="Back()" nzType="backward" nzTheme="fill" />
+    </ng-template>
+    <ng-template #check>
+        <nz-icon (click)="submitForm()" nzType="check" nzTheme="outline" />
+    </ng-template>
+}

src/app/pages/staff/staff-card/staff-card.ts

@@ -0,0 +1,89 @@
+import {Component, inject, input, output, signal} from '@angular/core';
+import {NzCardComponent} from "ng-zorro-antd/card";
+import {NzColDirective, NzRowDirective} from "ng-zorro-antd/grid";
+import {NzFormControlComponent, NzFormDirective, NzFormItemComponent, NzFormLabelComponent} from "ng-zorro-antd/form";
+import {NzIconDirective} from "ng-zorro-antd/icon";
+import {NzInputDirective} from "ng-zorro-antd/input";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {firstValueFrom} from "rxjs";
+import {GetStaffDto, StaffsService, UpdateStaffDto} from "../../../services/api";
+
+@Component({
+  selector: 'app-staff-card',
+    imports: [
+        NzCardComponent,
+        NzColDirective,
+        NzFormControlComponent,
+        NzFormDirective,
+        NzFormItemComponent,
+        NzFormLabelComponent,
+        NzIconDirective,
+        NzInputDirective,
+        NzRowDirective,
+        ReactiveFormsModule
+    ],
+  templateUrl: './staff-card.html',
+  styleUrl: './staff-card.css',
+})
+export class StaffCard {
+    private staffsService = inject(StaffsService);
+    private notificationService = inject(NzNotificationService)
+
+    staffEdit = signal<UpdateStaffDto>(null);
+    staffsLoading = signal<boolean>(false);
+
+    staffForm = new FormGroup({
+        f4T2NumberApproval: new FormControl<string>(null, [Validators.required]),
+        f4T2ExpirationDate: new FormControl<Date>(null, [Validators.required]),
+    })
+
+    async submitForm() {
+        this.staffsLoading.set(true);
+
+        const staffValue: UpdateStaffDto = {
+            f4T2NumberApproval: this.staffForm.value.f4T2NumberApproval,
+            f4T2ExpirationDate: this.staffForm.value.f4T2ExpirationDate,
+        }
+
+        try {
+            const staff = await firstValueFrom(this.staffsService.updateStaffEndpoint(this.staff().id, staffValue));
+            this.staffEdit.set(staff as unknown as UpdateStaffDto);
+            console.log(staff);
+            this.staffForm.reset();
+            this.edit.set(false);
+            this.triggerEdited.emit();
+        } catch (e) {
+            this.notificationService.error('Erreur', '(ou Erreur de communication avec l\'API)');
+        }
+
+        this.staffsLoading.set(false);
+    }
+
+    staff = input<GetStaffDto>(null);
+    edit = signal(false)
+    triggerEdited = output<void>();
+
+    protected Edit() {
+        this.edit.set(true)
+    }
+
+    protected Back() {
+        this.edit.set(false)
+        this.staffForm.reset();
+    }
+
+    async Delete() {
+        this.staffsLoading.set(true);
+
+        try {
+            await firstValueFrom(this.staffsService.deleteStaffEndpoint(this.staff().id));
+            this.staffForm.reset();
+            this.triggerEdited.emit();
+        } catch (e) {
+            this.notificationService.error('Erreur', '(ou Erreur de communication avec l\'API)');
+        }
+
+        this.staffsLoading.set(false);
+    }
+}

src/app/pages/staff/staff.html

@@ -1 +1,11 @@
-<p>staff works!</p>
+<app-create-staff-modal (triggerCreated)="fetchStaff()" />
+
+<div class="card">
+    <div nz-row [nzGutter]="10" style="gap: 30px">
+        @for (staff of staffs(); track staff.id)
+        {
+            <!-- Passage de la donnée du parent vers l'enfant + signal à émettre -->
+            <app-staff-card [staff]="staff" (triggerEdited)="fetchStaff()" />
+        }
+    </div>
+</div>

src/app/pages/staff/staff.ts

@@ -1,11 +1,40 @@
-import { Component } from '@angular/core';
+import {Component, inject, signal} from '@angular/core';
+import {NzRowDirective} from "ng-zorro-antd/grid";
+import {GetStaffDto, StaffsService} from "../../services/api";
+import {NzNotificationService} from "ng-zorro-antd/notification";
+import {Router} from "@angular/router";
+import {firstValueFrom} from "rxjs";
+import {CreateStaffModal} from "./create-staff-modal/create-staff-modal";
+import {StaffCard} from "./staff-card/staff-card";
 
 @Component({
   selector: 'app-staff',
-  imports: [],
+    imports: [NzRowDirective, CreateStaffModal, StaffCard,],
   templateUrl: './staff.html',
   styleUrl: './staff.css',
 })
 export class Staff {
+    private staffsService = inject(StaffsService);
+    private notificationService = inject(NzNotificationService)
 
+    router = inject(Router);
+
+    staffs = signal<GetStaffDto[]>([]);
+    staffsLoading = signal<boolean>(false);
+
+    async ngOnInit() {
+        await this.fetchStaff();
+    }
+
+    async fetchStaff() {
+        this.staffsLoading.set(true);
+        try {
+            const staff = await firstValueFrom(this.staffsService.getAllStaffsEndpoint())
+            this.staffs.set(staff)
+        } catch (e) {
+            this.notificationService.error('Erreur', 'Erreur de communication avec l\'API');
+        }
+
+        this.staffsLoading.set(false);
+    }
 }

src/app/services/api/.gitignore

@@ -0,0 +1,4 @@
+wwwroot/*.js
+node_modules
+typings
+dist

src/app/services/api/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

src/app/services/api/.openapi-generator/FILES

@@ -0,0 +1,54 @@
+.gitignore
+.openapi-generator-ignore
+README.md
+api.base.service.ts
+api.module.ts
+api/api.ts
+api/availabilities.service.ts
+api/communications.service.ts
+api/contacts.service.ts
+api/customers.service.ts
+api/customertypes.service.ts
+api/experiencelevels.service.ts
+api/historyofapprovals.service.ts
+api/providertypes.service.ts
+api/serviceproviders.service.ts
+api/staffs.service.ts
+configuration.ts
+encoder.ts
+git_push.sh
+index.ts
+model/create-availability-dto.ts
+model/create-communication-dto.ts
+model/create-contact-dto.ts
+model/create-customer-dto.ts
+model/create-customer-type-dto.ts
+model/create-experience-level-dto.ts
+model/create-history-of-approval-dto.ts
+model/create-provider-dto.ts
+model/create-provider-type-dto.ts
+model/create-staff-dto.ts
+model/get-availability-dto.ts
+model/get-communication-dto.ts
+model/get-contact-dto.ts
+model/get-customer-dto.ts
+model/get-customer-type-dto.ts
+model/get-experience-level-dto.ts
+model/get-history-of-approval-dto.ts
+model/get-provider-dto.ts
+model/get-provider-type-dto.ts
+model/get-staff-dto.ts
+model/models.ts
+model/update-availability-dto.ts
+model/update-communication-dto.ts
+model/update-contact-dto.ts
+model/update-customer-dto.ts
+model/update-customer-type-dto.ts
+model/update-experience-level-dto.ts
+model/update-history-of-approval-dto.ts
+model/update-provider-dto.ts
+model/update-provider-type-dto.ts
+model/update-staff-dto.ts
+param.ts
+provide-api.ts
+variables.ts

src/app/services/api/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.17.0

src/app/services/api/README.md

@@ -0,0 +1,185 @@
+# @
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.0.0
+
+## Building
+
+To install the required dependencies and to build the typescript sources run:
+
+```console
+npm install
+npm run build
+```
+
+## Publishing
+
+First build the package then run `npm publish dist` (don't forget to specify the `dist` folder!)
+
+## Consuming
+
+Navigate to the folder of your consuming project and run one of next commands.
+
+_published:_
+
+```console
+npm install @ --save
+```
+
+_without publishing (not recommended):_
+
+```console
+npm install PATH_TO_GENERATED_PACKAGE/dist.tgz --save
+```
+
+_It's important to take the tgz file, otherwise you'll get trouble with links on windows_
+
+_using `npm link`:_
+
+In PATH_TO_GENERATED_PACKAGE/dist:
+
+```console
+npm link
+```
+
+In your project:
+
+```console
+npm link 
+```
+
+__Note for Windows users:__ The Angular CLI has troubles to use linked npm packages.
+Please refer to this issue <https://github.com/angular/angular-cli/issues/8284> for a solution / workaround.
+Published packages are not effected by this issue.
+
+### General usage
+
+In your Angular project:
+
+```typescript
+
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi()
+    ],
+};
+```
+
+**NOTE**
+If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you can still import an Angular module:
+```typescript
+import { ApiModule } from '';
+```
+
+If different from the generated base path, during app bootstrap, you can provide the base path to your service.
+
+```typescript
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi('http://localhost:9999')
+    ],
+};
+```
+
+```typescript
+// with a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi({
+            withCredentials: true,
+            username: 'user',
+            password: 'password'
+        })
+    ],
+};
+```
+
+```typescript
+// with factory building a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi, Configuration } from '';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        {
+            provide: Configuration,
+            useFactory: (authService: AuthService) => new Configuration({
+                    basePath: 'http://localhost:9999',
+                    withCredentials: true,
+                    username: authService.getUsername(),
+                    password: authService.getPassword(),
+            }),
+            deps: [AuthService],
+            multi: false
+        }
+    ],
+};
+```
+
+### Using multiple OpenAPI files / APIs
+
+In order to use multiple APIs generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
+
+```typescript
+import { provideApi as provideUserApi } from 'my-user-api-path';
+import { provideApi as provideAdminApi } from 'my-admin-api-path';
+import { HttpClientModule } from '@angular/common/http';
+import { environment } from '../environments/environment';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideUserApi(environment.basePath),
+        provideAdminApi(environment.basePath),
+    ],
+};
+```
+
+### Customizing path parameter encoding
+
+Without further customization, only [path-parameters][parameter-locations-url] of [style][style-values-url] 'simple'
+and Dates for format 'date-time' are encoded correctly.
+
+Other styles (e.g. "matrix") are not that easy to encode
+and thus are best delegated to other libraries (e.g.: [@honoluluhenk/http-param-expander]).
+
+To implement your own parameter encoding (or call another library),
+pass an arrow-function or method-reference to the `encodeParam` property of the Configuration-object
+(see [General Usage](#general-usage) above).
+
+Example value for use in your Configuration-Provider:
+
+```typescript
+new Configuration({
+    encodeParam: (param: Param) => myFancyParamEncoder(param),
+})
+```
+
+[parameter-locations-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
+[style-values-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
+[@honoluluhenk/http-param-expander]: https://www.npmjs.com/package/@honoluluhenk/http-param-expander

src/app/services/api/api.base.service.ts

@@ -0,0 +1,83 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { CustomHttpParameterCodec } from './encoder';
+import { Configuration } from './configuration';
+
+export class BaseService {
+    protected basePath = 'http://localhost:5298';
+    public defaultHeaders = new HttpHeaders();
+    public configuration: Configuration;
+    public encoder: HttpParameterCodec;
+
+    constructor(basePath?: string|string[], configuration?: Configuration) {
+        this.configuration = configuration || new Configuration();
+        if (typeof this.configuration.basePath !== 'string') {
+            const firstBasePath = Array.isArray(basePath) ? basePath[0] : undefined;
+            if (firstBasePath != undefined) {
+                basePath = firstBasePath;
+            }
+
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+
+    protected canConsumeForm(consumes: string[]): boolean {
+        return consumes.indexOf('multipart/form-data') !== -1;
+    }
+
+    protected addToHttpParams(httpParams: HttpParams, value: any, key?: string, isDeep: boolean = false): HttpParams {
+        // If the value is an object (but not a Date), recursively add its keys.
+        if (typeof value === 'object' && !(value instanceof Date)) {
+            return this.addToHttpParamsRecursive(httpParams, value, isDeep ? key : undefined, isDeep);
+        }
+        return this.addToHttpParamsRecursive(httpParams, value, key);
+    }
+
+    protected addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string, isDeep: boolean = false): HttpParams {
+        if (value === null || value === undefined) {
+            return httpParams;
+        }
+        if (typeof value === 'object') {
+            // If JSON format is preferred, key must be provided.
+            if (key != null) {
+                return isDeep
+                    ? Object.keys(value as Record<string, any>).reduce(
+                        (hp, k) => hp.append(`${key}[${k}]`, value[k]),
+                        httpParams,
+                    )
+                    : httpParams.append(key, JSON.stringify(value));
+            }
+            // Otherwise, if it's an array, add each element.
+            if (Array.isArray(value)) {
+                value.forEach(elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));
+            } else if (value instanceof Date) {
+                if (key != null) {
+                    httpParams = httpParams.append(key, value.toISOString());
+                } else {
+                    throw Error("key may not be null if value is Date");
+                }
+            } else {
+                Object.keys(value).forEach(k => {
+                    const paramKey = key ? `${key}.${k}` : k;
+                    httpParams = this.addToHttpParamsRecursive(httpParams, value[k], paramKey);
+                });
+            }
+            return httpParams;
+        } else if (key != null) {
+            return httpParams.append(key, value);
+        }
+        throw Error("key may not be null if value is not object or array");
+    }
+}

src/app/services/api/api.module.ts

@@ -0,0 +1,30 @@
+import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';
+import { Configuration } from './configuration';
+import { HttpClient } from '@angular/common/http';
+
+
+@NgModule({
+  imports:      [],
+  declarations: [],
+  exports:      [],
+  providers: []
+})
+export class ApiModule {
+    public static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ApiModule> {
+        return {
+            ngModule: ApiModule,
+            providers: [ { provide: Configuration, useFactory: configurationFactory } ]
+        };
+    }
+
+    constructor( @Optional() @SkipSelf() parentModule: ApiModule,
+                 @Optional() http: HttpClient) {
+        if (parentModule) {
+            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');
+        }
+        if (!http) {
+            throw new Error('You need to import the HttpClientModule in your AppModule! \n' +
+            'See also https://github.com/angular/angular/issues/20575');
+        }
+    }
+}

src/app/services/api/api/api.ts

@@ -0,0 +1,21 @@
+export * from './availabilities.service';
+import { AvailabilitiesService } from './availabilities.service';
+export * from './communications.service';
+import { CommunicationsService } from './communications.service';
+export * from './contacts.service';
+import { ContactsService } from './contacts.service';
+export * from './customers.service';
+import { CustomersService } from './customers.service';
+export * from './customertypes.service';
+import { CustomertypesService } from './customertypes.service';
+export * from './experiencelevels.service';
+import { ExperiencelevelsService } from './experiencelevels.service';
+export * from './historyofapprovals.service';
+import { HistoryofapprovalsService } from './historyofapprovals.service';
+export * from './providertypes.service';
+import { ProvidertypesService } from './providertypes.service';
+export * from './serviceproviders.service';
+import { ServiceprovidersService } from './serviceproviders.service';
+export * from './staffs.service';
+import { StaffsService } from './staffs.service';
+export const APIS = [AvailabilitiesService, CommunicationsService, ContactsService, CustomersService, CustomertypesService, ExperiencelevelsService, HistoryofapprovalsService, ProvidertypesService, ServiceprovidersService, StaffsService];

src/app/services/api/api/availabilities.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateAvailabilityDto } from '../model/create-availability-dto';
+// @ts-ignore
+import { GetAvailabilityDto } from '../model/get-availability-dto';
+// @ts-ignore
+import { UpdateAvailabilityDto } from '../model/update-availability-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AvailabilitiesService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/availabilities
+     * @param createAvailabilityDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetAvailabilityDto>;
+    public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetAvailabilityDto>>;
+    public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetAvailabilityDto>>;
+    public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createAvailabilityDto === null || createAvailabilityDto === undefined) {
+            throw new Error('Required parameter createAvailabilityDto was null or undefined when calling createAvailabilityEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/availabilities`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetAvailabilityDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createAvailabilityDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/availabilities/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteAvailabilityEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetAvailabilityDto>;
+    public deleteAvailabilityEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetAvailabilityDto>>;
+    public deleteAvailabilityEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetAvailabilityDto>>;
+    public deleteAvailabilityEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteAvailabilityEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/availabilities/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetAvailabilityDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/availabilities
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllAvailabilityxuest(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAvailabilityDto>>;
+    public getAllAvailabilityxuest(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAvailabilityDto>>>;
+    public getAllAvailabilityxuest(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAvailabilityDto>>>;
+    public getAllAvailabilityxuest(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/availabilities`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetAvailabilityDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/availabilities/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAvailabilityEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetAvailabilityDto>;
+    public getAvailabilityEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetAvailabilityDto>>;
+    public getAvailabilityEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetAvailabilityDto>>;
+    public getAvailabilityEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getAvailabilityEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/availabilities/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetAvailabilityDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/availabilities/{id}
+     * @param id 
+     * @param updateAvailabilityDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetAvailabilityDto>;
+    public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetAvailabilityDto>>;
+    public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetAvailabilityDto>>;
+    public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateAvailabilityEndpoint.');
+        }
+        if (updateAvailabilityDto === null || updateAvailabilityDto === undefined) {
+            throw new Error('Required parameter updateAvailabilityDto was null or undefined when calling updateAvailabilityEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/availabilities/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetAvailabilityDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateAvailabilityDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/communications.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateCommunicationDto } from '../model/create-communication-dto';
+// @ts-ignore
+import { GetCommunicationDto } from '../model/get-communication-dto';
+// @ts-ignore
+import { UpdateCommunicationDto } from '../model/update-communication-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CommunicationsService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/communications
+     * @param createCommunicationDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCommunicationDto>;
+    public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCommunicationDto>>;
+    public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCommunicationDto>>;
+    public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createCommunicationDto === null || createCommunicationDto === undefined) {
+            throw new Error('Required parameter createCommunicationDto was null or undefined when calling createCommunicationEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/communications`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCommunicationDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createCommunicationDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/communications/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteCommunicationEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCommunicationDto>;
+    public deleteCommunicationEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCommunicationDto>>;
+    public deleteCommunicationEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCommunicationDto>>;
+    public deleteCommunicationEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteCommunicationEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/communications/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCommunicationDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/communications
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllCommunicationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetCommunicationDto>>;
+    public getAllCommunicationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetCommunicationDto>>>;
+    public getAllCommunicationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetCommunicationDto>>>;
+    public getAllCommunicationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/communications`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetCommunicationDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/communications/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getCommunicationEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCommunicationDto>;
+    public getCommunicationEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCommunicationDto>>;
+    public getCommunicationEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCommunicationDto>>;
+    public getCommunicationEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getCommunicationEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/communications/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCommunicationDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/communications/{id}
+     * @param id 
+     * @param updateCommunicationDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCommunicationDto>;
+    public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCommunicationDto>>;
+    public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCommunicationDto>>;
+    public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateCommunicationEndpoint.');
+        }
+        if (updateCommunicationDto === null || updateCommunicationDto === undefined) {
+            throw new Error('Required parameter updateCommunicationDto was null or undefined when calling updateCommunicationEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/communications/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCommunicationDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateCommunicationDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/contacts.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateContactDto } from '../model/create-contact-dto';
+// @ts-ignore
+import { GetContactDto } from '../model/get-contact-dto';
+// @ts-ignore
+import { UpdateContactDto } from '../model/update-contact-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ContactsService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/contacts
+     * @param createContactDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createContactEndpoint(createContactDto: CreateContactDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetContactDto>;
+    public createContactEndpoint(createContactDto: CreateContactDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetContactDto>>;
+    public createContactEndpoint(createContactDto: CreateContactDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetContactDto>>;
+    public createContactEndpoint(createContactDto: CreateContactDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createContactDto === null || createContactDto === undefined) {
+            throw new Error('Required parameter createContactDto was null or undefined when calling createContactEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/contacts`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetContactDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createContactDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/contacts/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteContactEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetContactDto>;
+    public deleteContactEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetContactDto>>;
+    public deleteContactEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetContactDto>>;
+    public deleteContactEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteContactEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/contacts/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetContactDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/contacts
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllContactEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetContactDto>>;
+    public getAllContactEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetContactDto>>>;
+    public getAllContactEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetContactDto>>>;
+    public getAllContactEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/contacts`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetContactDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/contacts/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getContactEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetContactDto>;
+    public getContactEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetContactDto>>;
+    public getContactEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetContactDto>>;
+    public getContactEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getContactEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/contacts/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetContactDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/contacts/{id}
+     * @param id 
+     * @param updateContactDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetContactDto>;
+    public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetContactDto>>;
+    public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetContactDto>>;
+    public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateContactEndpoint.');
+        }
+        if (updateContactDto === null || updateContactDto === undefined) {
+            throw new Error('Required parameter updateContactDto was null or undefined when calling updateContactEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/contacts/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetContactDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateContactDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/customers.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateCustomerDto } from '../model/create-customer-dto';
+// @ts-ignore
+import { GetCustomerDto } from '../model/get-customer-dto';
+// @ts-ignore
+import { UpdateCustomerDto } from '../model/update-customer-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CustomersService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/customers
+     * @param createCustomerDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerDto>;
+    public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerDto>>;
+    public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerDto>>;
+    public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createCustomerDto === null || createCustomerDto === undefined) {
+            throw new Error('Required parameter createCustomerDto was null or undefined when calling createCustomerEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customers`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createCustomerDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/customers/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteCustomerEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerDto>;
+    public deleteCustomerEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerDto>>;
+    public deleteCustomerEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerDto>>;
+    public deleteCustomerEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteCustomerEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customers/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/customers
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllCustomerEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetCustomerDto>>;
+    public getAllCustomerEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetCustomerDto>>>;
+    public getAllCustomerEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetCustomerDto>>>;
+    public getAllCustomerEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customers`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetCustomerDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/customers/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getCustomerEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerDto>;
+    public getCustomerEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerDto>>;
+    public getCustomerEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerDto>>;
+    public getCustomerEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getCustomerEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customers/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/customers/{id}
+     * @param id 
+     * @param updateCustomerDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerDto>;
+    public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerDto>>;
+    public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerDto>>;
+    public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateCustomer.');
+        }
+        if (updateCustomerDto === null || updateCustomerDto === undefined) {
+            throw new Error('Required parameter updateCustomerDto was null or undefined when calling updateCustomer.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customers/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateCustomerDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/customertypes.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateCustomerTypeDto } from '../model/create-customer-type-dto';
+// @ts-ignore
+import { GetCustomerTypeDto } from '../model/get-customer-type-dto';
+// @ts-ignore
+import { UpdateCustomerTypeDto } from '../model/update-customer-type-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CustomertypesService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/customertypes
+     * @param createCustomerTypeDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerTypeDto>;
+    public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerTypeDto>>;
+    public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerTypeDto>>;
+    public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createCustomerTypeDto === null || createCustomerTypeDto === undefined) {
+            throw new Error('Required parameter createCustomerTypeDto was null or undefined when calling createCustomerTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customertypes`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerTypeDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createCustomerTypeDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/customertypes/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteCustomerTypeEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerTypeDto>;
+    public deleteCustomerTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerTypeDto>>;
+    public deleteCustomerTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerTypeDto>>;
+    public deleteCustomerTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteCustomerTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerTypeDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/customertypes
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllCustomerTypeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetCustomerTypeDto>>;
+    public getAllCustomerTypeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetCustomerTypeDto>>>;
+    public getAllCustomerTypeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetCustomerTypeDto>>>;
+    public getAllCustomerTypeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customertypes`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetCustomerTypeDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/customertypes/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getCustomerTypeEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerTypeDto>;
+    public getCustomerTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerTypeDto>>;
+    public getCustomerTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerTypeDto>>;
+    public getCustomerTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getCustomerTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerTypeDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/customertypes/{id}
+     * @param id 
+     * @param updateCustomerTypeDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetCustomerTypeDto>;
+    public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetCustomerTypeDto>>;
+    public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetCustomerTypeDto>>;
+    public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateCustomerType.');
+        }
+        if (updateCustomerTypeDto === null || updateCustomerTypeDto === undefined) {
+            throw new Error('Required parameter updateCustomerTypeDto was null or undefined when calling updateCustomerType.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/customertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetCustomerTypeDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateCustomerTypeDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/experiencelevels.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateExperienceLevelDto } from '../model/create-experience-level-dto';
+// @ts-ignore
+import { GetExperienceLevelDto } from '../model/get-experience-level-dto';
+// @ts-ignore
+import { UpdateExperienceLevelDto } from '../model/update-experience-level-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ExperiencelevelsService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/experiencelevels
+     * @param createExperienceLevelDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetExperienceLevelDto>;
+    public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetExperienceLevelDto>>;
+    public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetExperienceLevelDto>>;
+    public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createExperienceLevelDto === null || createExperienceLevelDto === undefined) {
+            throw new Error('Required parameter createExperienceLevelDto was null or undefined when calling createExperienceLevelEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/experiencelevels`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetExperienceLevelDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createExperienceLevelDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/experiencelevels/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteExerienceLevelEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetExperienceLevelDto>;
+    public deleteExerienceLevelEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetExperienceLevelDto>>;
+    public deleteExerienceLevelEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetExperienceLevelDto>>;
+    public deleteExerienceLevelEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteExerienceLevelEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/experiencelevels/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetExperienceLevelDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/experiencelevels
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllExperienceLevelsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetExperienceLevelDto>>;
+    public getAllExperienceLevelsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetExperienceLevelDto>>>;
+    public getAllExperienceLevelsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetExperienceLevelDto>>>;
+    public getAllExperienceLevelsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/experiencelevels`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetExperienceLevelDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/experiencelevels/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getExperienceLevelEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetExperienceLevelDto>;
+    public getExperienceLevelEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetExperienceLevelDto>>;
+    public getExperienceLevelEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetExperienceLevelDto>>;
+    public getExperienceLevelEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getExperienceLevelEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/experiencelevels/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetExperienceLevelDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/experiencelevels/{id}
+     * @param id 
+     * @param updateExperienceLevelDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateExperienceLevelEndpoint(id: number, updateExperienceLevelDto: UpdateExperienceLevelDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetExperienceLevelDto>;
+    public updateExperienceLevelEndpoint(id: number, updateExperienceLevelDto: UpdateExperienceLevelDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetExperienceLevelDto>>;
+    public updateExperienceLevelEndpoint(id: number, updateExperienceLevelDto: UpdateExperienceLevelDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetExperienceLevelDto>>;
+    public updateExperienceLevelEndpoint(id: number, updateExperienceLevelDto: UpdateExperienceLevelDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateExperienceLevelEndpoint.');
+        }
+        if (updateExperienceLevelDto === null || updateExperienceLevelDto === undefined) {
+            throw new Error('Required parameter updateExperienceLevelDto was null or undefined when calling updateExperienceLevelEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/experiencelevels/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetExperienceLevelDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateExperienceLevelDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/historyofapprovals.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateHistoryOfApprovalDto } from '../model/create-history-of-approval-dto';
+// @ts-ignore
+import { GetHistoryOfApprovalDto } from '../model/get-history-of-approval-dto';
+// @ts-ignore
+import { UpdateHistoryOfApprovalDto } from '../model/update-history-of-approval-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HistoryofapprovalsService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/historyofapprovals
+     * @param createHistoryOfApprovalDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createHistoryOfApprovalEndpoint(createHistoryOfApprovalDto: CreateHistoryOfApprovalDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetHistoryOfApprovalDto>;
+    public createHistoryOfApprovalEndpoint(createHistoryOfApprovalDto: CreateHistoryOfApprovalDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetHistoryOfApprovalDto>>;
+    public createHistoryOfApprovalEndpoint(createHistoryOfApprovalDto: CreateHistoryOfApprovalDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetHistoryOfApprovalDto>>;
+    public createHistoryOfApprovalEndpoint(createHistoryOfApprovalDto: CreateHistoryOfApprovalDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createHistoryOfApprovalDto === null || createHistoryOfApprovalDto === undefined) {
+            throw new Error('Required parameter createHistoryOfApprovalDto was null or undefined when calling createHistoryOfApprovalEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/historyofapprovals`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetHistoryOfApprovalDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createHistoryOfApprovalDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/historyofapprovals/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteHistoryOfApprovalEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetHistoryOfApprovalDto>;
+    public deleteHistoryOfApprovalEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetHistoryOfApprovalDto>>;
+    public deleteHistoryOfApprovalEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetHistoryOfApprovalDto>>;
+    public deleteHistoryOfApprovalEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteHistoryOfApprovalEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/historyofapprovals/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetHistoryOfApprovalDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/historyofapprovals
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllHistoryOfApprovalEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetHistoryOfApprovalDto>>;
+    public getAllHistoryOfApprovalEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetHistoryOfApprovalDto>>>;
+    public getAllHistoryOfApprovalEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetHistoryOfApprovalDto>>>;
+    public getAllHistoryOfApprovalEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/historyofapprovals`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetHistoryOfApprovalDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/historyofapprovals/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getHistoryOfApprovalEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetHistoryOfApprovalDto>;
+    public getHistoryOfApprovalEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetHistoryOfApprovalDto>>;
+    public getHistoryOfApprovalEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetHistoryOfApprovalDto>>;
+    public getHistoryOfApprovalEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getHistoryOfApprovalEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/historyofapprovals/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetHistoryOfApprovalDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/historyofapprovals/{id}
+     * @param id 
+     * @param updateHistoryOfApprovalDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateHistoryOfApprovalEndpoint(id: number, updateHistoryOfApprovalDto: UpdateHistoryOfApprovalDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetHistoryOfApprovalDto>;
+    public updateHistoryOfApprovalEndpoint(id: number, updateHistoryOfApprovalDto: UpdateHistoryOfApprovalDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetHistoryOfApprovalDto>>;
+    public updateHistoryOfApprovalEndpoint(id: number, updateHistoryOfApprovalDto: UpdateHistoryOfApprovalDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetHistoryOfApprovalDto>>;
+    public updateHistoryOfApprovalEndpoint(id: number, updateHistoryOfApprovalDto: UpdateHistoryOfApprovalDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateHistoryOfApprovalEndpoint.');
+        }
+        if (updateHistoryOfApprovalDto === null || updateHistoryOfApprovalDto === undefined) {
+            throw new Error('Required parameter updateHistoryOfApprovalDto was null or undefined when calling updateHistoryOfApprovalEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/historyofapprovals/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetHistoryOfApprovalDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateHistoryOfApprovalDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/providertypes.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateProviderTypeDto } from '../model/create-provider-type-dto';
+// @ts-ignore
+import { GetProviderTypeDto } from '../model/get-provider-type-dto';
+// @ts-ignore
+import { UpdateProviderTypeDto } from '../model/update-provider-type-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ProvidertypesService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/providertypes
+     * @param createProviderTypeDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createProviderTypeEndpoint(createProviderTypeDto: CreateProviderTypeDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderTypeDto>;
+    public createProviderTypeEndpoint(createProviderTypeDto: CreateProviderTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderTypeDto>>;
+    public createProviderTypeEndpoint(createProviderTypeDto: CreateProviderTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderTypeDto>>;
+    public createProviderTypeEndpoint(createProviderTypeDto: CreateProviderTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createProviderTypeDto === null || createProviderTypeDto === undefined) {
+            throw new Error('Required parameter createProviderTypeDto was null or undefined when calling createProviderTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/providertypes`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderTypeDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createProviderTypeDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/providertypes/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteProviderTypeEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderTypeDto>;
+    public deleteProviderTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderTypeDto>>;
+    public deleteProviderTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderTypeDto>>;
+    public deleteProviderTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteProviderTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/providertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderTypeDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/providertypes
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllProviderTypesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetProviderTypeDto>>;
+    public getAllProviderTypesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetProviderTypeDto>>>;
+    public getAllProviderTypesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetProviderTypeDto>>>;
+    public getAllProviderTypesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/providertypes`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetProviderTypeDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/providertypes/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getProviderTypeEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderTypeDto>;
+    public getProviderTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderTypeDto>>;
+    public getProviderTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderTypeDto>>;
+    public getProviderTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getProviderTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/providertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderTypeDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/providertypes/{id}
+     * @param id 
+     * @param updateProviderTypeDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateProviderTypeEndpoint(id: number, updateProviderTypeDto: UpdateProviderTypeDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderTypeDto>;
+    public updateProviderTypeEndpoint(id: number, updateProviderTypeDto: UpdateProviderTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderTypeDto>>;
+    public updateProviderTypeEndpoint(id: number, updateProviderTypeDto: UpdateProviderTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderTypeDto>>;
+    public updateProviderTypeEndpoint(id: number, updateProviderTypeDto: UpdateProviderTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateProviderTypeEndpoint.');
+        }
+        if (updateProviderTypeDto === null || updateProviderTypeDto === undefined) {
+            throw new Error('Required parameter updateProviderTypeDto was null or undefined when calling updateProviderTypeEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/providertypes/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderTypeDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateProviderTypeDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/serviceproviders.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateProviderDto } from '../model/create-provider-dto';
+// @ts-ignore
+import { GetProviderDto } from '../model/get-provider-dto';
+// @ts-ignore
+import { UpdateProviderDto } from '../model/update-provider-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ServiceprovidersService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/serviceproviders
+     * @param createProviderDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createProviderEndpoint(createProviderDto: CreateProviderDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderDto>;
+    public createProviderEndpoint(createProviderDto: CreateProviderDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderDto>>;
+    public createProviderEndpoint(createProviderDto: CreateProviderDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderDto>>;
+    public createProviderEndpoint(createProviderDto: CreateProviderDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createProviderDto === null || createProviderDto === undefined) {
+            throw new Error('Required parameter createProviderDto was null or undefined when calling createProviderEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/serviceproviders`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createProviderDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/serviceproviders/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteProviderEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderDto>;
+    public deleteProviderEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderDto>>;
+    public deleteProviderEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderDto>>;
+    public deleteProviderEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteProviderEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/serviceproviders/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/serviceproviders
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllProvidersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetProviderDto>>;
+    public getAllProvidersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetProviderDto>>>;
+    public getAllProvidersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetProviderDto>>>;
+    public getAllProvidersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/serviceproviders`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetProviderDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/serviceproviders/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getProviderEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderDto>;
+    public getProviderEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderDto>>;
+    public getProviderEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderDto>>;
+    public getProviderEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getProviderEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/serviceproviders/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/serviceproviders/{id}
+     * @param id 
+     * @param updateProviderDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateProviderEndpoint(id: number, updateProviderDto: UpdateProviderDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetProviderDto>;
+    public updateProviderEndpoint(id: number, updateProviderDto: UpdateProviderDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetProviderDto>>;
+    public updateProviderEndpoint(id: number, updateProviderDto: UpdateProviderDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetProviderDto>>;
+    public updateProviderEndpoint(id: number, updateProviderDto: UpdateProviderDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateProviderEndpoint.');
+        }
+        if (updateProviderDto === null || updateProviderDto === undefined) {
+            throw new Error('Required parameter updateProviderDto was null or undefined when calling updateProviderEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/serviceproviders/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetProviderDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateProviderDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/api/staffs.service.ts

@@ -0,0 +1,332 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+// @ts-ignore
+import { CreateStaffDto } from '../model/create-staff-dto';
+// @ts-ignore
+import { GetStaffDto } from '../model/get-staff-dto';
+// @ts-ignore
+import { UpdateStaffDto } from '../model/update-staff-dto';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StaffsService extends BaseService {
+
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
+        super(basePath, configuration);
+    }
+
+    /**
+     * @endpoint post /API/staffs
+     * @param createStaffDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public createStaffEndpoint(createStaffDto: CreateStaffDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetStaffDto>;
+    public createStaffEndpoint(createStaffDto: CreateStaffDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetStaffDto>>;
+    public createStaffEndpoint(createStaffDto: CreateStaffDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetStaffDto>>;
+    public createStaffEndpoint(createStaffDto: CreateStaffDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (createStaffDto === null || createStaffDto === undefined) {
+            throw new Error('Required parameter createStaffDto was null or undefined when calling createStaffEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/staffs`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetStaffDto>('post', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: createStaffDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint delete /API/staffs/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public deleteStaffEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetStaffDto>;
+    public deleteStaffEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetStaffDto>>;
+    public deleteStaffEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetStaffDto>>;
+    public deleteStaffEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling deleteStaffEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/staffs/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetStaffDto>('delete', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/staffs
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getAllStaffsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetStaffDto>>;
+    public getAllStaffsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetStaffDto>>>;
+    public getAllStaffsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetStaffDto>>>;
+    public getAllStaffsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/staffs`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<Array<GetStaffDto>>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint get /API/staffs/{id}
+     * @param id 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public getStaffEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetStaffDto>;
+    public getStaffEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetStaffDto>>;
+    public getStaffEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetStaffDto>>;
+    public getStaffEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getStaffEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/staffs/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetStaffDto>('get', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * @endpoint put /API/staffs/{id}
+     * @param id 
+     * @param updateStaffDto 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public updateStaffEndpoint(id: number, updateStaffDto: UpdateStaffDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetStaffDto>;
+    public updateStaffEndpoint(id: number, updateStaffDto: UpdateStaffDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetStaffDto>>;
+    public updateStaffEndpoint(id: number, updateStaffDto: UpdateStaffDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetStaffDto>>;
+    public updateStaffEndpoint(id: number, updateStaffDto: UpdateStaffDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling updateStaffEndpoint.');
+        }
+        if (updateStaffDto === null || updateStaffDto === undefined) {
+            throw new Error('Required parameter updateStaffDto was null or undefined when calling updateStaffEndpoint.');
+        }
+
+        let localVarHeaders = this.defaultHeaders;
+
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+        const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' | 'blob' = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            } else {
+                responseType_ = 'blob';
+            }
+        }
+
+        let localVarPath = `/API/staffs/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
+        return this.httpClient.request<GetStaffDto>('put', `${basePath}${localVarPath}`,
+            {
+                context: localVarHttpContext,
+                body: updateStaffDto,
+                responseType: <any>responseType_,
+                ...(withCredentials ? { withCredentials } : {}),
+                headers: localVarHeaders,
+                observe: observe,
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

src/app/services/api/configuration.ts

@@ -0,0 +1,193 @@
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { Param } from './param';
+
+export interface ConfigurationParameters {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {[ key: string ]: string};
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Override the default method for encoding path parameters in various
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam?: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials?: {[ key: string ]: string | (() => string | undefined)};
+}
+
+export class Configuration {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {[ key: string ]: string};
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Encoding of various path parameter
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials: {[ key: string ]: string | (() => string | undefined)};
+
+constructor({ accessToken, apiKeys, basePath, credentials, encodeParam, encoder, password, username, withCredentials }: ConfigurationParameters = {}) {
+        if (apiKeys) {
+            this.apiKeys = apiKeys;
+        }
+        if (username !== undefined) {
+            this.username = username;
+        }
+        if (password !== undefined) {
+            this.password = password;
+        }
+        if (accessToken !== undefined) {
+            this.accessToken = accessToken;
+        }
+        if (basePath !== undefined) {
+            this.basePath = basePath;
+        }
+        if (withCredentials !== undefined) {
+            this.withCredentials = withCredentials;
+        }
+        if (encoder) {
+            this.encoder = encoder;
+        }
+        this.encodeParam = encodeParam ?? (param => this.defaultEncodeParam(param));
+        this.credentials = credentials ?? {};
+
+        // init default JWTBearerAuth credential
+        if (!this.credentials['JWTBearerAuth']) {
+            this.credentials['JWTBearerAuth'] = () => {
+                return typeof this.accessToken === 'function'
+                    ? this.accessToken()
+                    : this.accessToken;
+            };
+        }
+    }
+
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    public selectHeaderContentType (contentTypes: string[]): string | undefined {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+
+        const type = contentTypes.find((x: string) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
+    }
+
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    public selectHeaderAccept(accepts: string[]): string | undefined {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+
+        const type = accepts.find((x: string) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    public isJsonMime(mime: string): boolean {
+        const jsonMime: RegExp = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+
+    public lookupCredential(key: string): string | undefined {
+        const value = this.credentials[key];
+        return typeof value === 'function'
+            ? value()
+            : value;
+    }
+
+    public addCredentialToHeaders(credentialKey: string, headerName: string, headers: HttpHeaders, prefix?: string): HttpHeaders {
+        const value = this.lookupCredential(credentialKey);
+        return value
+            ? headers.set(headerName, (prefix ?? '') + value)
+            : headers;
+    }
+
+    public addCredentialToQuery(credentialKey: string, paramName: string, query: HttpParams): HttpParams {
+        const value = this.lookupCredential(credentialKey);
+        return value
+            ? query.set(paramName, value)
+            : query;
+    }
+
+    private defaultEncodeParam(param: Param): string {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+
+        const value = param.dataFormat === 'date-time' && param.value instanceof Date
+            ? (param.value as Date).toISOString()
+            : param.value;
+
+        return encodeURIComponent(String(value));
+    }
+}

src/app/services/api/encoder.ts

@@ -0,0 +1,20 @@
+import { HttpParameterCodec } from '@angular/common/http';
+
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export class CustomHttpParameterCodec implements HttpParameterCodec {
+    encodeKey(k: string): string {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v: string): string {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k: string): string {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v: string): string {
+        return decodeURIComponent(v);
+    }
+}

src/app/services/api/git_push.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-petstore-perl "minor update" "gitlab.com"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+git_host=$4
+
+if [ "$git_host" = "" ]; then
+    git_host="github.com"
+    echo "[INFO] No command line input provided. Set \$git_host to $git_host"
+fi
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="GIT_USER_ID"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="GIT_REPO_ID"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="Minor update"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=$(git remote)
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+        git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:"${GIT_TOKEN}"@${git_host}/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'

src/app/services/api/index.ts

@@ -0,0 +1,7 @@
+export * from './api/api';
+export * from './model/models';
+export * from './variables';
+export * from './configuration';
+export * from './api.module';
+export * from './provide-api';
+export * from './param';

src/app/services/api/model/create-availability-dto.ts

@@ -0,0 +1,18 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateAvailabilityDto { 
+    availabilityDate?: string;
+    deliveryDate?: string;
+    expirationDate?: string;
+    renewalDate?: string;
+}
+

src/app/services/api/model/create-communication-dto.ts

@@ -0,0 +1,18 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateCommunicationDto { 
+    calling?: string | null;
+    email?: string | null;
+    meeting?: string | null;
+    contactId?: number;
+}
+

src/app/services/api/model/create-contact-dto.ts

@@ -0,0 +1,22 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateContactDto { 
+    lastName?: string | null;
+    firstName?: string | null;
+    phoneNumber?: string | null;
+    email?: string | null;
+    address?: string | null;
+    city?: string | null;
+    role?: string | null;
+    customerId?: number | null;
+}
+

src/app/services/api/model/create-customer-dto.ts

@@ -0,0 +1,16 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateCustomerDto { 
+    note?: string | null;
+    customerTypeId?: number;
+}
+

src/app/services/api/model/create-customer-type-dto.ts

@@ -0,0 +1,15 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateCustomerTypeDto { 
+    label?: string | null;
+}
+

src/app/services/api/model/create-experience-level-dto.ts

@@ -0,0 +1,16 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateExperienceLevelDto { 
+    label?: string | null;
+    staffId?: number | null;
+}
+

src/app/services/api/model/create-history-of-approval-dto.ts

@@ -0,0 +1,17 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateHistoryOfApprovalDto { 
+    deliveryDate?: string;
+    expirationDate?: string;
+    staffId?: number;
+}
+

src/app/services/api/model/create-provider-dto.ts

@@ -0,0 +1,16 @@
+/**
+ * PyroFetes
+ *
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface CreateProviderDto { 
+    price?: number;
+    providerTypeId?: number;
+}
+