diff --git a/src/app/app.routes.ts b/src/app/app.routes.ts
index 9d068cd..1556a7d 100644
--- a/src/app/app.routes.ts
+++ b/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)
},
{
diff --git a/src/app/app.ts b/src/app/app.ts
index 16a99a4..e04f8f4 100644
--- a/src/app/app.ts
+++ b/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'
})
diff --git a/src/app/pages/contact/contact-add-form/contact-add-form.css b/src/app/pages/contact/contact-add-form/contact-add-form.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/contact/contact-add-form/contact-add-form.html b/src/app/pages/contact/contact-add-form/contact-add-form.html
new file mode 100644
index 0000000..9cf3fbf
--- /dev/null
+++ b/src/app/pages/contact/contact-add-form/contact-add-form.html
@@ -0,0 +1,61 @@
+
\ No newline at end of file
diff --git a/src/app/pages/contact/contact-add-form/contact-add-form.ts b/src/app/pages/contact/contact-add-form/contact-add-form.ts
new file mode 100644
index 0000000..604001f
--- /dev/null
+++ b/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
(null, [Validators.required]),
+ firstName: new FormControl(null, [Validators.required]),
+ phoneNumber: 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]),
+ customerId: new FormControl(null),
+ })
+
+ contactPost = signal(this.contactForm.value);
+ contactsLoading = signal(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);
+ }
+}
diff --git a/src/app/pages/contact/contact-card/contact-card.css b/src/app/pages/contact/contact-card/contact-card.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/contact/contact-card/contact-card.html b/src/app/pages/contact/contact-card/contact-card.html
new file mode 100644
index 0000000..331e35b
--- /dev/null
+++ b/src/app/pages/contact/contact-card/contact-card.html
@@ -0,0 +1,70 @@
+@if (edit() == false) {
+
+ Contact n°{{ contact().id }}
+ Nom : {{ contact().lastName + " " + contact().firstName }}
+ Rôle : {{ contact().role }}
+ Numéro de téléphone : {{ contact().phoneNumber }}
+ Email : {{ contact().email }}
+ Adresse : {{ contact().address + ", " + contact().city }}
+
+
+
+
+
+
+
+
+} @else {
+
+
+
+
+
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/app/pages/contact/contact-card/contact-card.ts b/src/app/pages/contact/contact-card/contact-card.ts
new file mode 100644
index 0000000..c8ef92d
--- /dev/null
+++ b/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(null);
+ contactsLoading = signal(false);
+
+ contactForm = new FormGroup({
+ id: new FormControl(null, [Validators.required]),
+ lastname: new FormControl(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(null);
+
+ edit = signal(false)
+
+ triggerEdited = output();
+
+ 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);
+ }
+}
diff --git a/src/app/pages/contact/contact.css b/src/app/pages/contact/contact.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/contact/contact.html b/src/app/pages/contact/contact.html
new file mode 100644
index 0000000..70b892c
--- /dev/null
+++ b/src/app/pages/contact/contact.html
@@ -0,0 +1,11 @@
+
+
+
+
+ @for (contact of contacts(); track contact.id)
+ {
+
+
+ }
+
+
diff --git a/src/app/pages/contact/contact.ts b/src/app/pages/contact/contact.ts
new file mode 100644
index 0000000..796710b
--- /dev/null
+++ b/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([]);
+ contactsLoading = signal(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);
+ }
+}
diff --git a/src/app/pages/contact/create-contact-modal/create-contact-modal.css b/src/app/pages/contact/create-contact-modal/create-contact-modal.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/contact/create-contact-modal/create-contact-modal.html b/src/app/pages/contact/create-contact-modal/create-contact-modal.html
new file mode 100644
index 0000000..9561a47
--- /dev/null
+++ b/src/app/pages/contact/create-contact-modal/create-contact-modal.html
@@ -0,0 +1 @@
+create-contact-modal works!
diff --git a/src/app/pages/contact/create-contact-modal/create-contact-modal.ts b/src/app/pages/contact/create-contact-modal/create-contact-modal.ts
new file mode 100644
index 0000000..e88f0df
--- /dev/null
+++ b/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: `
+
+
+ Création de contacts
+
+
+
+
+
+
+
+
+
+
+ `,
+ 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()
+}
diff --git a/src/app/pages/customers/create-customers-modal/customers-card-form.css b/src/app/pages/customers/create-customers-modal/customers-card-form.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/customers/create-customers-modal/customers-card-form.html b/src/app/pages/customers/create-customers-modal/customers-card-form.html
new file mode 100644
index 0000000..4b55f97
--- /dev/null
+++ b/src/app/pages/customers/create-customers-modal/customers-card-form.html
@@ -0,0 +1 @@
+customers-card-form works!
diff --git a/src/app/pages/customers/create-customers-modal/customers-card-form.ts b/src/app/pages/customers/create-customers-modal/customers-card-form.ts
new file mode 100644
index 0000000..a20b2fc
--- /dev/null
+++ b/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: `
+
+
+ Création de clients
+
+
+
+
+
+
+
+
+
+
+ `,
+ 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()
+}
\ No newline at end of file
diff --git a/src/app/pages/customers/customers-add-form/customers-add-form.css b/src/app/pages/customers/customers-add-form/customers-add-form.css
new file mode 100644
index 0000000..eb7e51c
--- /dev/null
+++ b/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 {
+
+}
diff --git a/src/app/pages/customers/customers-add-form/customers-add-form.html b/src/app/pages/customers/customers-add-form/customers-add-form.html
new file mode 100644
index 0000000..9d888b2
--- /dev/null
+++ b/src/app/pages/customers/customers-add-form/customers-add-form.html
@@ -0,0 +1,23 @@
+
diff --git a/src/app/pages/customers/customers-add-form/customers-add-form.ts b/src/app/pages/customers/customers-add-form/customers-add-form.ts
new file mode 100644
index 0000000..2f61b14
--- /dev/null
+++ b/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(null, [Validators.required]),
+ customerTypeId: new FormControl(null, [Validators.required]),
+ })
+
+ customerPost = signal(this.customerForm.value);
+ customersLoading = signal(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([])
+
+ 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);
+ }
+}
diff --git a/src/app/pages/customers/customers-card/get-all-customers-card.css b/src/app/pages/customers/customers-card/get-all-customers-card.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/customers/customers-card/get-all-customers-card.html b/src/app/pages/customers/customers-card/get-all-customers-card.html
new file mode 100644
index 0000000..944568d
--- /dev/null
+++ b/src/app/pages/customers/customers-card/get-all-customers-card.html
@@ -0,0 +1,30 @@
+@if (edit() == false) {
+
+ Client n°{{ customer().id }}
+ Note : {{ customer().note }}
+ Type de client : {{ customer().customerType}}
+
+
+
+
+
+
+
+} @else {
+
+
+
+
+
+
+
+
+
+}
diff --git a/src/app/pages/customers/customers-card/get-all-customers-card.ts b/src/app/pages/customers/customers-card/get-all-customers-card.ts
new file mode 100644
index 0000000..c06483f
--- /dev/null
+++ b/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(null);
+ customersLoading = signal(false);
+
+ customerForm = new FormGroup({
+ id: new FormControl(null, [Validators.required]),
+ note: new FormControl(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(null);
+
+ edit = signal(false)
+
+ triggerEdited = output();
+
+ 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);
+ }
+}
diff --git a/src/app/pages/customers/customers.html b/src/app/pages/customers/customers.html
index 7ed2f32..7d7576a 100644
--- a/src/app/pages/customers/customers.html
+++ b/src/app/pages/customers/customers.html
@@ -1 +1,11 @@
-customers works!
+
+
+
+
+ @for (customer of customers(); track customer.id)
+ {
+
+
+ }
+
+
\ No newline at end of file
diff --git a/src/app/pages/customers/customers.ts b/src/app/pages/customers/customers.ts
index 43d4a36..4f9235c 100644
--- a/src/app/pages/customers/customers.ts
+++ b/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([]);
+ customersLoading = signal(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);
+ }
+}
\ No newline at end of file
diff --git a/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.css b/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.html b/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.html
new file mode 100644
index 0000000..c704788
--- /dev/null
+++ b/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.html
@@ -0,0 +1 @@
+create-opportunity-modal works!
diff --git a/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.ts b/src/app/pages/opportunities/create-opportunity-modal/create-opportunity-modal.ts
new file mode 100644
index 0000000..d3599df
--- /dev/null
+++ b/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: `
+
+
+ Création d'opportunités
+
+
+
+
+
+
+
+
+
+
+ `,
+ 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()
+}
diff --git a/src/app/pages/opportunities/opportunities.html b/src/app/pages/opportunities/opportunities.html
index 5b82714..2de5708 100644
--- a/src/app/pages/opportunities/opportunities.html
+++ b/src/app/pages/opportunities/opportunities.html
@@ -1 +1,57 @@
-opportunities works!
+
+
+
+
+
+
+
+
📞 Appels
+
{{ totalCalls }}
+
+
+
✉️ Emails
+
{{ totalEmails }}
+
+
+
🤝 Réunions
+
{{ totalMeetings }}
+
+
+
+
+
+
+
+
+
+ @for (communication of communications(); track communication.id) {
+ @if (communication.calling) {
+
+
+ }
+ }
+
+
+
+
+
+ @for (communication of communications(); track communication.id) {
+ @if (communication.email) {
+
+
+ }
+ }
+
+
+
+
+
+ @for (communication of communications(); track communication.id) {
+ @if (communication.meeting) {
+
+
+ }
+ }
+
+
+
\ No newline at end of file
diff --git a/src/app/pages/opportunities/opportunities.ts b/src/app/pages/opportunities/opportunities.ts
index e287f5b..2b373a5 100644
--- a/src/app/pages/opportunities/opportunities.ts
+++ b/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([]);
+ communicationsLoading = signal(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);
+ }
}
diff --git a/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.css b/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.html b/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.html
new file mode 100644
index 0000000..59f6bf6
--- /dev/null
+++ b/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.html
@@ -0,0 +1,37 @@
+
\ No newline at end of file
diff --git a/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.ts b/src/app/pages/opportunities/opportunity-add-form/opportunity-add-form.ts
new file mode 100644
index 0000000..d1ec64b
--- /dev/null
+++ b/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(null),
+ email: new FormControl(null),
+ meeting: new FormControl(null),
+ contactId: new FormControl(null, [Validators.required]),
+ }, { validators: atLeastOneRequired })
+
+ communicationPost = signal(this.communicationForm.value);
+ communicationsLoading = signal(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([]);
+
+ 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 };
+ }
diff --git a/src/app/pages/opportunities/opportunity-card/opportunity-card.css b/src/app/pages/opportunities/opportunity-card/opportunity-card.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/opportunities/opportunity-card/opportunity-card.html b/src/app/pages/opportunities/opportunity-card/opportunity-card.html
new file mode 100644
index 0000000..e25a26a
--- /dev/null
+++ b/src/app/pages/opportunities/opportunity-card/opportunity-card.html
@@ -0,0 +1,58 @@
+@if (edit() == false) {
+
+ Contact n°{{ communication().contactId }}
+ @if (communication().calling) {
+ 📞 Appel : {{ communication().calling }}
+ Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}
+ Numéro du Contact : {{ communication().contactPhoneNumber }}
+ Email du Contact : {{ communication().contactEmail }}
+ }
+ @if (communication().email) {
+ ✉️ Email : {{ communication().email }}
+ Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}
+ Numéro du Contact : {{ communication().contactPhoneNumber }}
+ Email du Contact : {{ communication().contactEmail }}
+ }
+ @if (communication().meeting) {
+ 🤝 Réunion : {{ communication().meeting }}
+ Nom du Contact : {{ communication().contactLastName + " " + communication().contactFirstName}}
+ Numéro du Contact : {{ communication().contactPhoneNumber }}
+ Email du Contact : {{ communication().contactEmail }}
+ }
+
+
+
+
+
+
+
+} @else {
+
+
+
+
+
+
+
+
+
+}
diff --git a/src/app/pages/opportunities/opportunity-card/opportunity-card.ts b/src/app/pages/opportunities/opportunity-card/opportunity-card.ts
new file mode 100644
index 0000000..447932c
--- /dev/null
+++ b/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(null);
+ communicationsLoading = signal(false);
+
+ communicationForm = new FormGroup({
+ calling: new FormControl(null),
+ email: new FormControl(null),
+ meeting: new FormControl(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(null);
+ edit = signal(false);
+ triggerEdited = output();
+
+ 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 };
+}
diff --git a/src/app/pages/providers/create-providers-modal/create-providers-modal.css b/src/app/pages/providers/create-providers-modal/create-providers-modal.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/providers/create-providers-modal/create-providers-modal.html b/src/app/pages/providers/create-providers-modal/create-providers-modal.html
new file mode 100644
index 0000000..1c34d8b
--- /dev/null
+++ b/src/app/pages/providers/create-providers-modal/create-providers-modal.html
@@ -0,0 +1 @@
+create-providers-modal works!
diff --git a/src/app/pages/providers/create-providers-modal/create-providers-modal.ts b/src/app/pages/providers/create-providers-modal/create-providers-modal.ts
new file mode 100644
index 0000000..551cc7e
--- /dev/null
+++ b/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: `
+
+
+ Création de prestataires
+
+
+
+
+
+
+
+
+
+
+ `,
+ 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()
+}
diff --git a/src/app/pages/providers/providers-add-form/providers-add-form.css b/src/app/pages/providers/providers-add-form/providers-add-form.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/providers/providers-add-form/providers-add-form.html b/src/app/pages/providers/providers-add-form/providers-add-form.html
new file mode 100644
index 0000000..69dfa7a
--- /dev/null
+++ b/src/app/pages/providers/providers-add-form/providers-add-form.html
@@ -0,0 +1,23 @@
+
diff --git a/src/app/pages/providers/providers-add-form/providers-add-form.ts b/src/app/pages/providers/providers-add-form/providers-add-form.ts
new file mode 100644
index 0000000..cbb7720
--- /dev/null
+++ b/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(null, [Validators.required]),
+ providerTypeId: new FormControl(null, [Validators.required]),
+ })
+
+ providerPost = signal(this.providerForm.value);
+ providersLoading = signal(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([])
+
+ 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);
+ }
+}
diff --git a/src/app/pages/providers/providers-card/providers-card.css b/src/app/pages/providers/providers-card/providers-card.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/providers/providers-card/providers-card.html b/src/app/pages/providers/providers-card/providers-card.html
new file mode 100644
index 0000000..e5b0da9
--- /dev/null
+++ b/src/app/pages/providers/providers-card/providers-card.html
@@ -0,0 +1,30 @@
+@if (edit() == false) {
+
+ Prestataire n°{{ provider().id }}
+ Prix : {{ provider().price }}
+ Type de Prestataire : {{ provider().providerType }}
+
+
+
+
+
+
+
+} @else {
+
+
+
+
+
+
+
+
+
+}
diff --git a/src/app/pages/providers/providers-card/providers-card.ts b/src/app/pages/providers/providers-card/providers-card.ts
new file mode 100644
index 0000000..8e52f43
--- /dev/null
+++ b/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(null);
+ providersLoading = signal(false);
+
+ providerForm = new FormGroup({
+ id: new FormControl(null, [Validators.required]),
+ price: new FormControl(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(null);
+
+ edit = signal(false)
+
+ triggerEdited = output();
+
+ 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);
+ }
+}
diff --git a/src/app/pages/providers/providers.html b/src/app/pages/providers/providers.html
index 5d1a3a1..6e1fd60 100644
--- a/src/app/pages/providers/providers.html
+++ b/src/app/pages/providers/providers.html
@@ -1 +1,11 @@
-providers works!
+
+
+
+
+ @for (provider of providers(); track provider.id)
+ {
+
+
+ }
+
+
\ No newline at end of file
diff --git a/src/app/pages/providers/providers.ts b/src/app/pages/providers/providers.ts
index de4acdb..b1b0557 100644
--- a/src/app/pages/providers/providers.ts
+++ b/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([]);
+ providersLoading = signal(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);
+ }
}
diff --git a/src/app/pages/staff/create-staff-modal/create-staff-modal.css b/src/app/pages/staff/create-staff-modal/create-staff-modal.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/staff/create-staff-modal/create-staff-modal.html b/src/app/pages/staff/create-staff-modal/create-staff-modal.html
new file mode 100644
index 0000000..50f5d70
--- /dev/null
+++ b/src/app/pages/staff/create-staff-modal/create-staff-modal.html
@@ -0,0 +1 @@
+create-staff-modal works!
diff --git a/src/app/pages/staff/create-staff-modal/create-staff-modal.ts b/src/app/pages/staff/create-staff-modal/create-staff-modal.ts
new file mode 100644
index 0000000..835acb8
--- /dev/null
+++ b/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: `
+
+
+ Création de staff
+
+
+
+
+
+
+
+
+
+
+ `,
+ 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()
+}
diff --git a/src/app/pages/staff/staff-add-form/staff-add-form.css b/src/app/pages/staff/staff-add-form/staff-add-form.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/staff/staff-add-form/staff-add-form.html b/src/app/pages/staff/staff-add-form/staff-add-form.html
new file mode 100644
index 0000000..678fcbb
--- /dev/null
+++ b/src/app/pages/staff/staff-add-form/staff-add-form.html
@@ -0,0 +1,47 @@
+
diff --git a/src/app/pages/staff/staff-add-form/staff-add-form.ts b/src/app/pages/staff/staff-add-form/staff-add-form.ts
new file mode 100644
index 0000000..56df90b
--- /dev/null
+++ b/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(null, [Validators.required]),
+ firstName: new FormControl(null, [Validators.required]),
+ profession: new FormControl(null, [Validators.required]),
+ email: new FormControl(null, [Validators.required]),
+ f4T2NumberApproval: new FormControl(null, [Validators.required]),
+ f4T2ExpirationDate: new FormControl(null, [Validators.required])
+ })
+
+ staffPost = signal(this.staffForm.value as any);
+ staffsLoading = signal(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([])
+
+ 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
diff --git a/src/app/pages/staff/staff-card/staff-card.css b/src/app/pages/staff/staff-card/staff-card.css
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/pages/staff/staff-card/staff-card.html b/src/app/pages/staff/staff-card/staff-card.html
new file mode 100644
index 0000000..09e0487
--- /dev/null
+++ b/src/app/pages/staff/staff-card/staff-card.html
@@ -0,0 +1,40 @@
+@if (edit() == false) {
+
+ Staff n°{{ staff().id }}
+ Nom : {{ staff().lastName }} {{ staff().firstName }}
+ Profession : {{ staff().profession }}
+ Email : {{ staff().email }}
+ N° F4T2 : {{ staff().f4T2NumberApproval }}
+ Expiration F4T2 : {{ staff().f4T2ExpirationDate }}
+ Niveau d'experience : {{ staff().experienceLevel}}
+
+
+
+
+
+
+
+} @else {
+
+
+
+
+
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/app/pages/staff/staff-card/staff-card.ts b/src/app/pages/staff/staff-card/staff-card.ts
new file mode 100644
index 0000000..ef46418
--- /dev/null
+++ b/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(null);
+ staffsLoading = signal(false);
+
+ staffForm = new FormGroup({
+ f4T2NumberApproval: new FormControl(null, [Validators.required]),
+ f4T2ExpirationDate: new FormControl(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(null);
+ edit = signal(false)
+ triggerEdited = output();
+
+ 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);
+ }
+}
diff --git a/src/app/pages/staff/staff.html b/src/app/pages/staff/staff.html
index f9500ec..3cf8b5b 100644
--- a/src/app/pages/staff/staff.html
+++ b/src/app/pages/staff/staff.html
@@ -1 +1,11 @@
-staff works!
+
+
+
+
+ @for (staff of staffs(); track staff.id)
+ {
+
+
+ }
+
+
\ No newline at end of file
diff --git a/src/app/pages/staff/staff.ts b/src/app/pages/staff/staff.ts
index 7464c3a..3ef9ab5 100644
--- a/src/app/pages/staff/staff.ts
+++ b/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([]);
+ staffsLoading = signal(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);
+ }
}
diff --git a/src/app/services/api/.gitignore b/src/app/services/api/.gitignore
new file mode 100644
index 0000000..149b576
--- /dev/null
+++ b/src/app/services/api/.gitignore
@@ -0,0 +1,4 @@
+wwwroot/*.js
+node_modules
+typings
+dist
diff --git a/src/app/services/api/.openapi-generator-ignore b/src/app/services/api/.openapi-generator-ignore
new file mode 100644
index 0000000..7484ee5
--- /dev/null
+++ b/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
diff --git a/src/app/services/api/.openapi-generator/FILES b/src/app/services/api/.openapi-generator/FILES
new file mode 100644
index 0000000..381935a
--- /dev/null
+++ b/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
diff --git a/src/app/services/api/.openapi-generator/VERSION b/src/app/services/api/.openapi-generator/VERSION
new file mode 100644
index 0000000..6328c54
--- /dev/null
+++ b/src/app/services/api/.openapi-generator/VERSION
@@ -0,0 +1 @@
+7.17.0
diff --git a/src/app/services/api/README.md b/src/app/services/api/README.md
new file mode 100644
index 0000000..c2ba935
--- /dev/null
+++ b/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 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
diff --git a/src/app/services/api/api.base.service.ts b/src/app/services/api/api.base.service.ts
new file mode 100644
index 0000000..1e0f210
--- /dev/null
+++ b/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).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");
+ }
+}
diff --git a/src/app/services/api/api.module.ts b/src/app/services/api/api.module.ts
new file mode 100644
index 0000000..58d341f
--- /dev/null
+++ b/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 {
+ 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');
+ }
+ }
+}
diff --git a/src/app/services/api/api/api.ts b/src/app/services/api/api/api.ts
new file mode 100644
index 0000000..bba0b75
--- /dev/null
+++ b/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];
diff --git a/src/app/services/api/api/availabilities.service.ts b/src/app/services/api/api/availabilities.service.ts
new file mode 100644
index 0000000..bb38167
--- /dev/null
+++ b/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;
+ public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createAvailabilityEndpoint(createAvailabilityDto: CreateAvailabilityDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createAvailabilityDto,
+ responseType: 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;
+ public deleteAvailabilityEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteAvailabilityEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteAvailabilityEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllAvailabilityxuest(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllAvailabilityxuest(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllAvailabilityxuest(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getAvailabilityEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getAvailabilityEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getAvailabilityEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateAvailabilityEndpoint(id: number, updateAvailabilityDto: UpdateAvailabilityDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('put', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: updateAvailabilityDto,
+ responseType: responseType_,
+ ...(withCredentials ? { withCredentials } : {}),
+ headers: localVarHeaders,
+ observe: observe,
+ ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+ reportProgress: reportProgress
+ }
+ );
+ }
+
+}
diff --git a/src/app/services/api/api/communications.service.ts b/src/app/services/api/api/communications.service.ts
new file mode 100644
index 0000000..6ccf985
--- /dev/null
+++ b/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;
+ public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCommunicationEndpoint(createCommunicationDto: CreateCommunicationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createCommunicationDto,
+ responseType: 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;
+ public deleteCommunicationEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCommunicationEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCommunicationEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllCommunicationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCommunicationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCommunicationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getCommunicationEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCommunicationEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCommunicationEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCommunicationEndpoint(id: number, updateCommunicationDto: UpdateCommunicationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('put', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: updateCommunicationDto,
+ responseType: responseType_,
+ ...(withCredentials ? { withCredentials } : {}),
+ headers: localVarHeaders,
+ observe: observe,
+ ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+ reportProgress: reportProgress
+ }
+ );
+ }
+
+}
diff --git a/src/app/services/api/api/contacts.service.ts b/src/app/services/api/api/contacts.service.ts
new file mode 100644
index 0000000..d8a5e13
--- /dev/null
+++ b/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;
+ public createContactEndpoint(createContactDto: CreateContactDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createContactEndpoint(createContactDto: CreateContactDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createContactEndpoint(createContactDto: CreateContactDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createContactDto,
+ responseType: 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;
+ public deleteContactEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteContactEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteContactEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllContactEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllContactEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllContactEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getContactEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getContactEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getContactEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateContactEndpoint(id: number, updateContactDto: UpdateContactDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('put', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: updateContactDto,
+ responseType: responseType_,
+ ...(withCredentials ? { withCredentials } : {}),
+ headers: localVarHeaders,
+ observe: observe,
+ ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+ reportProgress: reportProgress
+ }
+ );
+ }
+
+}
diff --git a/src/app/services/api/api/customers.service.ts b/src/app/services/api/api/customers.service.ts
new file mode 100644
index 0000000..5d8adf2
--- /dev/null
+++ b/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;
+ public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCustomerEndpoint(createCustomerDto: CreateCustomerDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createCustomerDto,
+ responseType: 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;
+ public deleteCustomerEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCustomerEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCustomerEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllCustomerEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCustomerEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCustomerEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getCustomerEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCustomerEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCustomerEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCustomer(id: number, updateCustomerDto: UpdateCustomerDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('put', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: updateCustomerDto,
+ responseType: responseType_,
+ ...(withCredentials ? { withCredentials } : {}),
+ headers: localVarHeaders,
+ observe: observe,
+ ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+ reportProgress: reportProgress
+ }
+ );
+ }
+
+}
diff --git a/src/app/services/api/api/customertypes.service.ts b/src/app/services/api/api/customertypes.service.ts
new file mode 100644
index 0000000..9c8f9ec
--- /dev/null
+++ b/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;
+ public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createCustomerTypeEndpoint(createCustomerTypeDto: CreateCustomerTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createCustomerTypeDto,
+ responseType: 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;
+ public deleteCustomerTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCustomerTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteCustomerTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllCustomerTypeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCustomerTypeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllCustomerTypeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getCustomerTypeEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCustomerTypeEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getCustomerTypeEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public updateCustomerType(id: number, updateCustomerTypeDto: UpdateCustomerTypeDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('put', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: updateCustomerTypeDto,
+ responseType: responseType_,
+ ...(withCredentials ? { withCredentials } : {}),
+ headers: localVarHeaders,
+ observe: observe,
+ ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
+ reportProgress: reportProgress
+ }
+ );
+ }
+
+}
diff --git a/src/app/services/api/api/experiencelevels.service.ts b/src/app/services/api/api/experiencelevels.service.ts
new file mode 100644
index 0000000..e6719c4
--- /dev/null
+++ b/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;
+ public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public createExperienceLevelEndpoint(createExperienceLevelDto: CreateExperienceLevelDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('post', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ body: createExperienceLevelDto,
+ responseType: 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;
+ public deleteExerienceLevelEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteExerienceLevelEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public deleteExerienceLevelEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+ 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('delete', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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>;
+ public getAllExperienceLevelsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllExperienceLevelsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>>;
+ public getAllExperienceLevelsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable {
+
+ 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>('get', `${basePath}${localVarPath}`,
+ {
+ context: localVarHttpContext,
+ responseType: 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;
+ public getExperienceLevelEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable>;
+ public getExperienceLevelEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable