Cleaned code

package-lock.json

@@ -22,6 +22,7 @@
         "@openapitools/openapi-generator-cli": "^2.30.2",
         "@tailwindcss/postcss": "^4.2.1",
         "browser-image-compression": "^2.0.2",
+        "jwt-decode": "^4.0.0",
         "moment": "^2.30.1",
         "postcss": "^8.5.8",
         "rimraf": "^6.1.3",
@@ -7158,6 +7159,15 @@
       ],
       "license": "MIT"
     },
+    "node_modules/jwt-decode": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jwt-decode/-/jwt-decode-4.0.0.tgz",
+      "integrity": "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/kleur": {
       "version": "4.1.5",
       "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",

package.json

@@ -36,6 +36,7 @@
     "@openapitools/openapi-generator-cli": "^2.30.2",
     "@tailwindcss/postcss": "^4.2.1",
     "browser-image-compression": "^2.0.2",
+    "jwt-decode": "^4.0.0",
     "moment": "^2.30.1",
     "postcss": "^8.5.8",
     "rimraf": "^6.1.3",

src/app/app.routes.ts

@@ -14,7 +14,7 @@ export const routes: Routes = [
             },
             {
                 path: 'groups',
-                loadComponent: () => import('./pages/groups/groups.component').then(m => m.GroupsComponent)
+                loadComponent: () => import('./pages/publication/publication.component').then(m => m.PublicationComponent)
             },
             {
                 path: 'ranking',

src/app/components/group-chat/group-chat.component.html

@@ -1,3 +0,0 @@
-<p>
-    group-chat works!
-</p>

src/app/components/group-chat/group-chat.component.ts

@@ -1,16 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-
-@Component({
-    selector: 'app-group-chat',
-    templateUrl: './group-chat.component.html',
-    styleUrls: ['./group-chat.component.scss'],
-})
-export class GroupChatComponent implements OnInit {
-
-    constructor() {
-    }
-
-    ngOnInit() {
-    }
-
-}

src/app/components/message-form/message-form.component.html

@@ -1,3 +1,8 @@
-<p>
-    message-form works!
-</p>
+<form [formGroup]="messageForm">
+    <ion-item lines="none" class="rounded-2xl border border-stone-200 mt-2">
+        <ion-input placeholder="Envoyer un message..." formControlName="libelle"></ion-input>
+        <ion-button style="--background: white" (click)="sendMessageOnGroup()">
+            <ion-icon name="send-outline" class="text-xl text-stone-400"></ion-icon>
+        </ion-button>
+    </ion-item>
+</form>

src/app/components/message-form/message-form.component.ts

@@ -1,16 +1,66 @@
-import {Component, OnInit} from '@angular/core';
+import {Component, inject, input} from '@angular/core';
+import {IonicModule, LoadingController, ToastController} from "@ionic/angular";
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
+import {addIcons} from "ionicons";
+import {sendOutline} from 'ionicons/icons';
+import {GetGroupDetailsDto, MessagesService} from "../../services/api";
+import {firstValueFrom} from "rxjs";
+
+addIcons({
+    "send-outline": sendOutline
+})
 
 @Component({
     selector: 'app-message-form',
     templateUrl: './message-form.component.html',
     styleUrls: ['./message-form.component.scss'],
+    imports: [
+        IonicModule,
+        ReactiveFormsModule
+    ]
 })
-export class MessageFormComponent implements OnInit {
+export class MessageFormComponent {
+    private messagesService = inject(MessagesService);
+    private loadCtrl = inject(LoadingController);
+    private toastCtrl = inject(ToastController);
 
-    constructor() {
+    groupId = input.required<GetGroupDetailsDto["id"]>();
+
+    messageForm: FormGroup = new FormGroup({
+        libelle: new FormControl<string>(null, [Validators.required]),
+    })
+
+    async sendMessageOnGroup() {
+        const loading = await this.loadCtrl.create({
+            message: 'Envoi...',
+            spinner: 'lines-sharp-small'
+        });
+        await loading.present();
+
+        if (this.messageForm.invalid) {
+            this.messageForm.reset();
+            const toast = await this.toastCtrl.create({
+                message: 'Message incorrect',
+                duration: 2000,
+                color: 'danger'
+            });
+            await toast.present();
+
+            return;
         }
 
-    ngOnInit() {
+        try {
+            await firstValueFrom(this.messagesService.sendMessageEndpoint(this.groupId(), this.messageForm.getRawValue()));
+            this.messageForm.reset();
+        } catch {
+            const toast = await this.toastCtrl.create({
+                message: 'Impossible d\'envoyer le messages.',
+                duration: 2000,
+                color: 'danger'
+            });
+            await toast.present();
+            this.messageForm.reset();
+        }
+        await loading.dismiss();
     }
-
 }

src/app/components/message/message.component.html

@@ -1,3 +1,24 @@
-<p>
-    message works!
-</p>
+@if (messages().length) {
+    <div class="overflow-scroll h-11/12">
+        <app-messages-list [messages]="messages()"></app-messages-list>
+    </div>
+} @else {
+    <ion-item lines="none" class="mt-[60%]" style="--background: #F7F6F2;">
+        <div class="flex flex-col items-center w-full gap-3">
+            <div class="relative w-14 h-14">
+                <div class="w-14 h-14 rounded-full bg-white border border-stone-200 flex items-center justify-center">
+                    <ion-icon name="chatbubble-ellipses-outline" class="text-2xl text-stone-400"></ion-icon>
+                </div>
+                <div class="absolute -bottom-0.5 -right-0.5 w-5 h-5 rounded-full bg-white border border-stone-200 flex items-center justify-center">
+                    <ion-icon name="moon-outline" class="text-[10px] text-stone-400"></ion-icon>
+                </div>
+            </div>
+            <div class="text-center flex flex-col gap-1">
+                <p class="m-0 text-sm font-medium text-stone-400">C'est bien calme par ici</p>
+                <p class="m-0 text-xs text-stone-300 leading-relaxed">Les messages du groupe apparaîtront ici</p>
+            </div>
+        </div>
+    </ion-item>
+}
+
+<app-message-form [groupId]="groupId()"></app-message-form>

src/app/components/message/message.component.ts

@@ -1,16 +1,60 @@
-import {Component, OnInit} from '@angular/core';
+import {Component, inject, input, OnDestroy, OnInit} from '@angular/core';
+import {GetGroupDetailsDto, MessagesService} from "../../services/api";
+import {firstValueFrom} from "rxjs";
+import {IonicModule, LoadingController, ToastController} from "@ionic/angular";
+import {addIcons} from "ionicons";
+import {chatbubbleEllipsesOutline, moonOutline} from 'ionicons/icons';
+import {ChatService} from "../../services/chat-service";
+import {MessagesListComponent} from "../messages-list/messages-list.component";
+import {MessageFormComponent} from "../message-form/message-form.component";
+
+addIcons({
+    "chatbubble-ellipses-outline": chatbubbleEllipsesOutline,
+    "moon-outline": moonOutline,
+})
 
 @Component({
     selector: 'app-message',
     templateUrl: './message.component.html',
     styleUrls: ['./message.component.scss'],
+    imports: [
+        IonicModule,
+        MessagesListComponent,
+        MessageFormComponent
+    ]
 })
-export class MessageComponent implements OnInit {
+export class MessageComponent implements OnInit, OnDestroy {
+    private messagesService = inject(MessagesService);
+    private loadCtrl = inject(LoadingController);
+    private toastCtrl = inject(ToastController);
+    private chatService = inject(ChatService);
 
-    constructor() {
+    messages = this.chatService.messages;
+    groupId = input.required<GetGroupDetailsDto["id"]>();
+
+    async ngOnInit() {
+        const loading = await this.loadCtrl.create({
+            message: 'Chargement...',
+            spinner: 'lines-sharp-small'
+        });
+        await loading.present();
+
+        try {
+            const messages = await firstValueFrom(this.messagesService.getMessagesEndpoint(this.groupId()));
+            this.chatService.setMessages(messages);
+            await this.chatService.connect(this.groupId());
+        } catch {
+            const toast = await this.toastCtrl.create({
+                message: 'Impossible de charger les messages.',
+                duration: 2000,
+                color: 'danger'
+            });
+            await toast.present();
+        }
+        await loading.dismiss();
     }
 
-    ngOnInit() {
+    async ngOnDestroy() {
+        await this.chatService.disconnect();
     }
-
 }

src/app/components/messages-list/messages-list.component.html

@@ -0,0 +1,36 @@
+<div class="m-3">
+    <app-title-part textInfo="Début de la conversation"></app-title-part>
+</div>
+
+@for (message of messages(); track message.id) {
+    @if (message.userId === currentUser) {
+        <div class="flex flex-row-reverse items-end">
+            <div class="flex flex-col items-end">
+                <div class="px-3.5 py-2 text-sm rounded-3xl rounded-br-sm bg-violet-700 text-white max-w-xs">
+                    {{ message.libelle }}
+                </div>
+                <span class="text-[10px] mt-0.5 mr-1 mb-0.5">
+                  {{ message.sendDate | date:'HH:mm' }}
+                </span>
+            </div>
+        </div>
+
+    } @else {
+        <div class="flex items-end gap-2">
+            <div class="w-8 h-8 rounded-full flex items-center justify-center text-xs mb-2 bg-teal-100 text-teal-700 max-w-xs">
+                {{ message.username.substring(0, 2) }}
+            </div>
+            <div class="flex flex-col">
+                <span class="text-[11px] mb-1 ml-1">
+                  {{ message.username }}
+                </span>
+                <div class="px-3.5 py-2 text-sm rounded-3xl rounded-bl-sm border">
+                    {{ message.libelle }}
+                </div>
+                <span class="text-[10px] mt-0.5 mx-1 mb-0.5">
+                  {{ message.sendDate | date:'HH:mm' }}
+                </span>
+            </div>
+        </div>
+    }
+}

src/app/components/messages-list/messages-list.component.ts

@@ -0,0 +1,24 @@
+import {Component, inject, input} from '@angular/core';
+import {DatePipe} from "@angular/common";
+import {IonicModule} from "@ionic/angular";
+import {GetMessageDto} from "../../services/api";
+import {jwtDecode} from "jwt-decode";
+import {AuthManageService} from "../../services/auth-manage";
+import {TitlePartComponent} from "../title-part/title-part.component";
+
+@Component({
+    selector: 'app-messages-list',
+    templateUrl: './messages-list.component.html',
+    styleUrls: ['./messages-list.component.scss'],
+    imports: [
+        DatePipe,
+        IonicModule,
+        TitlePartComponent
+    ]
+})
+export class MessagesListComponent {
+    private authService = inject(AuthManageService);
+
+    messages = input.required<GetMessageDto[]>();
+    currentUser = Number(jwtDecode<any>(this.authService.getToken()).UserId);
+}

src/app/components/navbar/navbar.component.html

@@ -10,7 +10,7 @@
         </ion-tab-button>
 
         <ion-tab-button tab="groups" routerLink="/groups">
-            <ion-icon name="chatbubbles-outline"></ion-icon>
+            <ion-icon name="globe-outline"></ion-icon>
         </ion-tab-button>
 
         <ion-tab-button tab="ranking" routerLink="/ranking">

src/app/components/navbar/navbar.component.ts

@@ -1,12 +1,12 @@
 import {Component} from '@angular/core';
 import {IonicModule} from "@ionic/angular";
 import {addIcons} from 'ionicons';
-import {homeOutline, peopleOutline, chatbubblesOutline, statsChartOutline} from 'ionicons/icons';
+import {homeOutline, peopleOutline, globeOutline, statsChartOutline} from 'ionicons/icons';
 
 addIcons({
     'home-outline': homeOutline,
     'people-outline': peopleOutline,
-    'chatbubbles-outline': chatbubblesOutline,
+    'globe-outline': globeOutline,
     'stats-chart-outline': statsChartOutline
 });
 

src/app/pages/groups/groups.component.ts

@@ -1,13 +0,0 @@
-import {Component} from '@angular/core';
-import {IonicModule} from "@ionic/angular";
-
-@Component({
-    selector: 'app-groups',
-    templateUrl: './groups.component.html',
-    styleUrls: ['./groups.component.scss'],
-    imports: [
-        IonicModule
-    ]
-})
-export class GroupsComponent {
-}

src/app/pages/home/home.component.html

@@ -49,7 +49,7 @@
 
     @if (groupSelected()) {
         <app-modal>
-            test
+            <app-message [groupId]="groupSelected().id"></app-message>
         </app-modal>
     }
 </ion-content>

src/app/pages/home/home.component.ts

@@ -5,8 +5,7 @@ import {personOutline, addOutline, settingsOutline, informationCircleOutline} fr
 import {TitlePartComponent} from "../../components/title-part/title-part.component";
 import {ChallengeCardComponent} from "../../components/challenge-card/challenge-card.component";
 import {
-    AchievementsService, CreateGroupDto,
-    GetAchievementDto, GetGroupDetailsDto, GetGroupDto,
+    AchievementsService, GetAchievementDto, GetGroupDetailsDto, GetGroupDto,
     GetRandomChallengeDto,
     GetUserChallengeDto,
     GetUserDetailsDto, GroupsService,
@@ -28,6 +27,7 @@ import {GalleryComponent} from "../../components/gallery/gallery.component";
 import {GroupsComponent} from "../../components/groups/groups.component";
 import {GroupFormComponent} from "../../components/group-form/group-form.component";
 import {GroupInfoComponent} from "../../components/group-info/group-info.component";
+import {MessageComponent} from "../../components/message/message.component";
 
 addIcons({
     'profile': personOutline,
@@ -59,6 +59,7 @@ type View = 'menu' | 'profile' | 'password' | 'designation' | 'gallery' | 'group
         GroupsComponent,
         GroupFormComponent,
         GroupInfoComponent,
+        MessageComponent,
     ]
 })
 export class HomeComponent implements OnInit {

src/app/pages/publication/publication.component.html

@@ -1,6 +1,6 @@
 <ion-header>
     <ion-toolbar>
-        <ion-title class="font-mono">Mes groupes</ion-title>
+        <ion-title class="font-mono">Publications</ion-title>
     </ion-toolbar>
 </ion-header>
 

src/app/pages/publication/publication.component.ts

@@ -0,0 +1,13 @@
+import {Component} from '@angular/core';
+import {IonicModule} from "@ionic/angular";
+
+@Component({
+    selector: 'app-publication',
+    templateUrl: './publication.component.html',
+    styleUrls: ['./publication.component.scss'],
+    imports: [
+        IonicModule
+    ]
+})
+export class PublicationComponent {
+}

src/app/pages/ranking/ranking.component.ts

@@ -11,17 +11,13 @@ import {firstValueFrom} from "rxjs";
         IonicModule
     ]
 })
-export class RankingComponent implements OnInit {
+export class RankingComponent {
     private overallRankingService = inject(OverallrankingService);
     private loadCtrl = inject(LoadingController);
     private toastCtrl = inject(ToastController);
 
     users = signal<GetUserDto[]>([]);
 
-    async ngOnInit() {
-        await this.fetchUsers();
-    }
-
     async ionViewWillEnter() {
         await this.fetchUsers();
     }

src/app/pages/social/social.component.ts

@@ -24,23 +24,10 @@ addIcons({
         SearchFriendComponent
     ]
 })
-export class SocialComponent implements OnInit {
+export class SocialComponent {
     private friendsState = inject(FriendsStateService);
     private loadCtrl = inject(LoadingController);
 
-    async ngOnInit() {
-        const loading = await this.loadCtrl.create({
-            message: 'Chargement...',
-            spinner: 'lines-sharp-small'
-        });
-        await loading.present();
-
-        await this.friendsState.fetchFriendsRequest();
-        await this.friendsState.fetchFriends();
-
-        await loading.dismiss();
-    }
-
     async ionViewWillEnter() {
         const loading = await this.loadCtrl.create({
             message: 'Chargement...',

src/app/services/api/README.md

@@ -73,9 +73,7 @@ export const appConfig: ApplicationConfig = {
 ```
 
 **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:
-
+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 '';
 ```
@@ -183,7 +181,5 @@ new Configuration({
 ```
 
 [parameter-locations-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
-
 [style-values-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
-
 [@honoluluhenk/http-param-expander]: https://www.npmjs.com/package/@honoluluhenk/http-param-expander

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -28,6 +27,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -43,26 +43,10 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetAchievementDto>>;
-    public getAllAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
-    public getAllAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
-    public getAllAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getAllAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getAllAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getAllAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -113,26 +97,10 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetAchievementDto>>;
-    public getLockedAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
-    public getLockedAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
-    public getLockedAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getLockedAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getLockedAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getLockedAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -183,26 +151,10 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetAchievementDto>>;
-    public getUserAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
-    public getUserAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
-    public getUserAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getUserAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getUserAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getUserAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -254,26 +206,10 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (achievementId === null || achievementId === undefined) {
             throw new Error('Required parameter achievementId was null or undefined when calling unlockAchievementEndpoint.');
         }
@@ -306,15 +242,7 @@ export class AchievementsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Achievements/${this.configuration.encodeParam({
-            name: "achievementId",
-            value: achievementId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Users`;
+        let localVarPath = `/API/Achievements/${this.configuration.encodeParam({name: "achievementId", value: achievementId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

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

@@ -1,31 +1,21 @@
 export * from './achievements.service';
 import { AchievementsService } from './achievements.service';
-
 export * from './auth.service';
 import { AuthService } from './auth.service';
-
 export * from './designations.service';
 import { DesignationsService } from './designations.service';
-
 export * from './friends.service';
 import { FriendsService } from './friends.service';
-
 export * from './groups.service';
 import { GroupsService } from './groups.service';
-
 export * from './messages.service';
 import { MessagesService } from './messages.service';
-
 export * from './overallranking.service';
 import { OverallrankingService } from './overallranking.service';
-
 export * from './posts.service';
 import { PostsService } from './posts.service';
-
 export * from './randomchallenges.service';
 import { RandomchallengesService } from './randomchallenges.service';
-
 export * from './users.service';
 import { UsersService } from './users.service';
-
 export const APIS = [AchievementsService, AuthService, DesignationsService, FriendsService, GroupsService, MessagesService, OverallrankingService, PostsService, RandomchallengesService, UsersService];

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -32,6 +31,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -48,26 +48,10 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetTokenDto>;
-    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetTokenDto>>;
-    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetTokenDto>>;
-    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
+    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
+    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
+    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (loginDto === null || loginDto === undefined) {
             throw new Error('Required parameter loginDto was null or undefined when calling loginEndpoint.');
         }
@@ -130,26 +114,10 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetTokenDto>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetTokenDto>>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetTokenDto>>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (refreshTokenDto === null || refreshTokenDto === undefined) {
             throw new Error('Required parameter refreshTokenDto was null or undefined when calling refreshTokenEndpoint.');
         }

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -26,6 +25,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -41,26 +41,10 @@ export class DesignationsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetDesignationDto>>;
-    public getAllDesignationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetDesignationDto>>>;
-    public getAllDesignationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetDesignationDto>>>;
-    public getAllDesignationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetDesignationDto>>;
+    public getAllDesignationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetDesignationDto>>>;
+    public getAllDesignationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetDesignationDto>>>;
+    public getAllDesignationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -28,6 +27,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -44,26 +44,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling acceptFriendRequestEndpoint.');
         }
@@ -73,7 +57,8 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -94,15 +79,7 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('put', `${basePath}${localVarPath}`,
             {
@@ -124,26 +101,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling deleteFriendEndpoint.');
         }
@@ -153,7 +114,8 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -174,15 +136,7 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -203,26 +157,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetFriendRequestDto>>;
-    public getAllFriendRequestsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetFriendRequestDto>>>;
-    public getAllFriendRequestsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetFriendRequestDto>>>;
-    public getAllFriendRequestsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendRequestDto>>;
+    public getAllFriendRequestsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendRequestDto>>>;
+    public getAllFriendRequestsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendRequestDto>>>;
+    public getAllFriendRequestsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -273,26 +211,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetFriendDto>>;
-    public getAllFriendsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetFriendDto>>>;
-    public getAllFriendsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetFriendDto>>>;
-    public getAllFriendsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendDto>>;
+    public getAllFriendsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendDto>>>;
+    public getAllFriendsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendDto>>>;
+    public getAllFriendsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -344,26 +266,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling rejectFriendRequestEndpoint.');
         }
@@ -373,7 +279,8 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -394,15 +301,7 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -424,26 +323,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public sendFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public sendFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling sendFriendRequestEndpoint.');
         }
@@ -453,7 +336,8 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -474,15 +358,7 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -34,6 +33,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -51,26 +51,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling addUserToGroupEndpoint.');
         }
@@ -83,7 +67,8 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -104,23 +89,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Users/${this.configuration.encodeParam({
-            name: "userId",
-            value: userId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {
@@ -142,26 +111,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (createGroupDto === null || createGroupDto === undefined) {
             throw new Error('Required parameter createGroupDto was null or undefined when calling createGroupEndpoint.');
         }
@@ -226,26 +179,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling deleteGroupEndpoint.');
         }
@@ -255,7 +192,8 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -276,15 +214,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Groups/${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<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -307,26 +237,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling deleteUserFromGroupEndpoint.');
         }
@@ -339,7 +253,8 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -360,23 +275,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Users/${this.configuration.encodeParam({
-            name: "userId",
-            value: userId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -398,26 +297,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetUserGroupDto>>;
-    public getAllGroupUsersEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetUserGroupDto>>>;
-    public getAllGroupUsersEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetUserGroupDto>>>;
-    public getAllGroupUsersEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserGroupDto>>;
+    public getAllGroupUsersEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserGroupDto>>>;
+    public getAllGroupUsersEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserGroupDto>>>;
+    public getAllGroupUsersEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getAllGroupUsersEndpoint.');
         }
@@ -450,15 +333,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Users`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetUserGroupDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -479,26 +354,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetGroupDto>>;
-    public getAllGroupsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetGroupDto>>>;
-    public getAllGroupsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetGroupDto>>>;
-    public getAllGroupsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetGroupDto>>;
+    public getAllGroupsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetGroupDto>>>;
+    public getAllGroupsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetGroupDto>>>;
+    public getAllGroupsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -550,26 +409,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetGroupDetailsDto>;
-    public getGroupDetailsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetGroupDetailsDto>>;
-    public getGroupDetailsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetGroupDetailsDto>>;
-    public getGroupDetailsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetGroupDetailsDto>;
+    public getGroupDetailsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetGroupDetailsDto>>;
+    public getGroupDetailsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetGroupDetailsDto>>;
+    public getGroupDetailsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getGroupDetailsEndpoint.');
         }
@@ -602,15 +445,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Groups/${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<GetGroupDetailsDto>('get', `${basePath}${localVarPath}`,
             {
@@ -632,26 +467,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public leaveGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public leaveGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public leaveGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public leaveGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public leaveGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public leaveGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public leaveGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public leaveGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling leaveGroupEndpoint.');
         }
@@ -661,7 +480,8 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -682,15 +502,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/User`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/User`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -713,26 +525,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetGroupDetailsDto>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetGroupDetailsDto>>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetGroupDetailsDto>>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetGroupDetailsDto>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetGroupDetailsDto>>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetGroupDetailsDto>>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling patchGroupUserRoleEndpoint.');
         }
@@ -768,23 +564,7 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Users/${this.configuration.encodeParam({
-            name: "userId",
-            value: userId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Role`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Role`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetGroupDetailsDto>('patch', `${basePath}${localVarPath}`,
             {

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -30,6 +29,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -47,26 +47,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteMessageEndpoint(id: number, groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling deleteMessageEndpoint.');
         }
@@ -79,7 +63,8 @@ export class MessagesService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -100,23 +85,7 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Messages/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -138,26 +107,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetMessageDto>>;
-    public getMessagesEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetMessageDto>>>;
-    public getMessagesEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetMessageDto>>>;
-    public getMessagesEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetMessageDto>>;
+    public getMessagesEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetMessageDto>>>;
+    public getMessagesEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetMessageDto>>>;
+    public getMessagesEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling getMessagesEndpoint.');
         }
@@ -190,15 +143,7 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetMessageDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -221,26 +166,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling sendMessageEndpoint.');
         }
@@ -285,15 +214,7 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({
-            name: "groupId",
-            value: groupId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -26,6 +25,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -41,26 +41,10 @@ export class OverallrankingService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetUserDto>>;
-    public getOverallRankingEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetUserDto>>>;
-    public getOverallRankingEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetUserDto>>>;
-    public getOverallRankingEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
+    public getOverallRankingEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
+    public getOverallRankingEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
+    public getOverallRankingEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -26,6 +25,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -41,26 +41,10 @@ export class PostsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllPostsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetPostDto>>;
-    public getAllPostsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetPostDto>>>;
-    public getAllPostsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetPostDto>>>;
-    public getAllPostsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllPostsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetPostDto>>;
+    public getAllPostsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetPostDto>>>;
+    public getAllPostsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetPostDto>>>;
+    public getAllPostsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -112,26 +96,10 @@ export class PostsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchLikeEndpoint(postId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchLikeEndpoint(postId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchLikeEndpoint(postId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchLikeEndpoint(postId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchLikeEndpoint(postId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchLikeEndpoint(postId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public patchLikeEndpoint(postId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public patchLikeEndpoint(postId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (postId === null || postId === undefined) {
             throw new Error('Required parameter postId was null or undefined when calling patchLikeEndpoint.');
         }
@@ -141,7 +109,8 @@ export class PostsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -162,15 +131,7 @@ export class PostsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Posts/${this.configuration.encodeParam({
-            name: "postId",
-            value: postId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Like`;
+        let localVarPath = `/API/Posts/${this.configuration.encodeParam({name: "postId", value: postId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Like`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -26,6 +25,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -41,26 +41,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetRandomChallengeDto>;
-    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetRandomChallengeDto>>;
-    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetRandomChallengeDto>>;
-    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
+    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -112,26 +96,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetRandomChallengeDto>;
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetRandomChallengeDto>>;
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetRandomChallengeDto>>;
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (randomChallengeId === null || randomChallengeId === undefined) {
             throw new Error('Required parameter randomChallengeId was null or undefined when calling getRandomChallengeEndpoint.');
         }
@@ -164,15 +132,7 @@ export class RandomchallengesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({
-            name: "randomChallengeId",
-            value: randomChallengeId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetRandomChallengeDto>('get', `${basePath}${localVarPath}`,
             {
@@ -196,26 +156,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (randomChallengeId === null || randomChallengeId === undefined) {
             throw new Error('Required parameter randomChallengeId was null or undefined when calling patchProofEndpoint.');
         }
@@ -225,7 +169,8 @@ export class RandomchallengesService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -271,15 +216,7 @@ export class RandomchallengesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({
-            name: "randomChallengeId",
-            value: randomChallengeId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Proof`;
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Proof`;
         const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {

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

@@ -10,8 +10,7 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
+import { HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
         }       from '@angular/common/http';
 import { Observable }                                        from 'rxjs';
@@ -42,6 +41,7 @@ import {Configuration} from '../configuration';
 import { BaseService } from '../api.base.service';
 
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -58,26 +58,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (createUserDto === null || createUserDto === undefined) {
             throw new Error('Required parameter createUserDto was null or undefined when calling createUserEndpoint.');
         }
@@ -138,33 +122,18 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteUserEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteUserEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteUserEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteUserEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteUserEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteUserEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -206,26 +175,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetUserChallengeDto>>;
-    public getAllUserChallengesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetUserChallengeDto>>>;
-    public getAllUserChallengesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetUserChallengeDto>>>;
-    public getAllUserChallengesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserChallengeDto>>;
+    public getAllUserChallengesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserChallengeDto>>>;
+    public getAllUserChallengesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserChallengeDto>>>;
+    public getAllUserChallengesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -276,26 +229,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetUserProofDto>>;
-    public getAllUserProofsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetUserProofDto>>>;
-    public getAllUserProofsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetUserProofDto>>>;
-    public getAllUserProofsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserProofDto>>;
+    public getAllUserProofsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserProofDto>>>;
+    public getAllUserProofsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserProofDto>>>;
+    public getAllUserProofsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -346,26 +283,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<Array<GetUserDto>>;
-    public getAllUsersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetUserDto>>>;
-    public getAllUsersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetUserDto>>>;
-    public getAllUsersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
+    public getAllUsersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
+    public getAllUsersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
+    public getAllUsersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -416,26 +337,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetUserDetailsDto>;
-    public getUserDetailsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetUserDetailsDto>>;
-    public getUserDetailsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetUserDetailsDto>>;
-    public getUserDetailsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDetailsDto>;
+    public getUserDetailsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDetailsDto>>;
+    public getUserDetailsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDetailsDto>>;
+    public getUserDetailsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -487,26 +392,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetUserDto>;
-    public getUserEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetUserDto>>;
-    public getUserEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetUserDto>>;
-    public getUserEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDto>;
+    public getUserEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDto>>;
+    public getUserEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDto>>;
+    public getUserEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getUserEndpoint.');
         }
@@ -539,15 +428,7 @@ export class UsersService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Users/${this.configuration.encodeParam({
-            name: "id",
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}`;
+        let localVarPath = `/API/Users/${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<GetUserDto>('get', `${basePath}${localVarPath}`,
             {
@@ -569,26 +450,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (patchUserDesignationDto === null || patchUserDesignationDto === undefined) {
             throw new Error('Required parameter patchUserDesignationDto was null or undefined when calling patchUserDesignationEndpoint.');
         }
@@ -653,26 +518,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (patchUserPasswordDto === null || patchUserPasswordDto === undefined) {
             throw new Error('Required parameter patchUserPasswordDto was null or undefined when calling patchUserPasswordEndpoint.');
         }
@@ -737,26 +586,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (updateUserDto === null || updateUserDto === undefined) {
             throw new Error('Required parameter updateUserDto was null or undefined when calling updateUserEndpoint.');
         }

src/app/services/api/configuration.ts

@@ -67,17 +67,7 @@ export class Configuration {
      */
     credentials: {[ key: string ]: string | (() => string | undefined)};
 
-    constructor({
-                    accessToken,
-                    apiKeys,
-                    basePath,
-                    credentials,
-                    encodeParam,
-                    encoder,
-                    password,
-                    username,
-                    withCredentials
-                }: ConfigurationParameters = {}) {
+constructor({ accessToken, apiKeys, basePath, credentials, encodeParam, encoder, password, username, withCredentials }: ConfigurationParameters = {}) {
         if (apiKeys) {
             this.apiKeys = apiKeys;
         }

src/app/services/api/encoder.ts

@@ -8,15 +8,12 @@ export class CustomHttpParameterCodec implements HttpParameterCodec {
     encodeKey(k: string): string {
         return encodeURIComponent(k);
     }
-
     encodeValue(v: string): string {
         return encodeURIComponent(v);
     }
-
     decodeKey(k: string): string {
         return decodeURIComponent(k);
     }
-
     decodeValue(v: string): string {
         return decodeURIComponent(v);
     }
@@ -26,15 +23,12 @@ export class IdentityHttpParameterCodec implements HttpParameterCodec {
     encodeKey(k: string): string {
         return k;
     }
-
     encodeValue(v: string): string {
         return v;
     }
-
     decodeKey(k: string): string {
         return k;
     }
-
     decodeValue(v: string): string {
         return v;
     }

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

@@ -11,6 +11,5 @@
 
 export interface CreateMessageDto { 
     libelle: string;
-    sendDate: string;
 }
 

src/app/services/chat-service.ts

@@ -0,0 +1,46 @@
+import {Injectable, signal} from "@angular/core";
+import {GetMessageDto} from "./api";
+import * as signalR from '@microsoft/signalr';
+
+@Injectable({
+    providedIn: 'root'
+})
+
+export class ChatService {
+    private hubConnection!: signalR.HubConnection;
+
+    messages = signal<GetMessageDto[]>([]);
+
+    async connect(groupId: number) {
+        if (this.hubConnection) return;
+
+        this.hubConnection = new signalR.HubConnectionBuilder()
+            .withUrl(`http://localhost:5235/groupHub?groupId=${groupId}`)
+            .withAutomaticReconnect()
+            .build();
+
+        await this.hubConnection.start();
+
+        this.hubConnection.on(
+            'ReceiveMessage',
+            (message: GetMessageDto) => {
+
+                this.messages.update(messages => [
+                    ...messages,
+                    message
+                ]);
+            }
+        );
+    }
+
+    async disconnect() {
+        if (this.hubConnection) {
+            await this.hubConnection.stop();
+            this.hubConnection = undefined!;
+        }
+    }
+
+    setMessages(messages: GetMessageDto[]) {
+        this.messages.set(messages);
+    }
+}

src/app/services/friends-state.ts

@@ -1,6 +1,6 @@
 import {inject, Injectable, signal} from '@angular/core';
 import {FriendsService, GetFriendDto, GetFriendRequestDto} from "./api";
-import {LoadingController, ToastController} from "@ionic/angular";
+import {ToastController} from "@ionic/angular";
 import {firstValueFrom} from "rxjs";
 
 @Injectable({