karibu-layer 1.0.13 → 1.0.15

package/README.md

@@ -1,8 +1,8 @@
 # karibu-layer@1.0.0
 
-API pour la gestion des établissements karibu
+API description of karibu
 
-The version of the OpenAPI document: 1.0
+The version of the OpenAPI document: 0.1-SNAPSHOT
 
 ## Building
 
@@ -58,157 +58,106 @@ Published packages are not effected by this issue.
 In your Angular project:
 
 ```typescript
-// without configuring providers
-import { ApiModule } from 'karibu-layer';
-import { HttpClientModule } from '@angular/common/http';
-
-@NgModule({
-    imports: [
-        ApiModule,
-        // make sure to import the HttpClientModule in the AppModule only,
-        // see https://github.com/angular/angular/issues/20575
-        HttpClientModule
-    ],
-    declarations: [ AppComponent ],
-    providers: [],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
 
-```typescript
-// configuring providers
-import { ApiModule, Configuration, ConfigurationParameters } from 'karibu-layer';
-
-export function apiConfigFactory (): Configuration {
-  const params: ConfigurationParameters = {
-    // set configuration parameters here.
-  }
-  return new Configuration(params);
-}
-
-@NgModule({
-    imports: [ ApiModule.forRoot(apiConfigFactory) ],
-    declarations: [ AppComponent ],
-    providers: [],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from 'karibu-layer';
 
-```typescript
-// configuring providers with an authentication service that manages your access tokens
-import { ApiModule, Configuration } from 'karibu-layer';
-
-@NgModule({
-    imports: [ ApiModule ],
-    declarations: [ AppComponent ],
+export const appConfig: ApplicationConfig = {
     providers: [
-      {
-        provide: Configuration,
-        useFactory: (authService: AuthService) => new Configuration(
-          {
-            basePath: environment.apiUrl,
-            accessToken: authService.getAccessToken.bind(authService)
-          }
-        ),
-        deps: [AuthService],
-        multi: false
-      }
+        // ...
+        provideHttpClient(),
+        provideApi()
     ],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
+};
 ```
 
+**NOTE**
+If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you can still import an Angular module:
 ```typescript
-import { DefaultApi } from 'karibu-layer';
-
-export class AppComponent {
-    constructor(private apiGateway: DefaultApi) { }
-}
+import { ApiModule } from 'karibu-layer';
 ```
 
-Note: The ApiModule is restricted to being instantiated once app wide.
-This is to ensure that all services are treated as singletons.
-
-### Using multiple OpenAPI files / APIs / ApiModules
-
-In order to use multiple `ApiModules` generated from different OpenAPI files,
-you can create an alias name when importing the modules
-in order to avoid naming conflicts:
+If different from the generated base path, during app bootstrap, you can provide the base path to your service.
 
 ```typescript
-import { ApiModule } from 'my-api-path';
-import { ApiModule as OtherApiModule } from 'my-other-api-path';
-import { HttpClientModule } from '@angular/common/http';
-
-@NgModule({
-  imports: [
-    ApiModule,
-    OtherApiModule,
-    // make sure to import the HttpClientModule in the AppModule only,
-    // see https://github.com/angular/angular/issues/20575
-    HttpClientModule
-  ]
-})
-export class AppModule {
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from 'karibu-layer';
 
-}
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi('http://localhost:9999')
+    ],
+};
 ```
 
-### Set service base path
-
-If different than the generated base path, during app bootstrap, you can provide the base path to your service.
-
 ```typescript
-import { BASE_PATH } from 'karibu-layer';
+// with a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from 'karibu-layer';
 
-bootstrap(AppComponent, [
-    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
-]);
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi({
+            withCredentials: true,
+            username: 'user',
+            password: 'password'
+        })
+    ],
+};
 ```
 
-or
-
 ```typescript
-import { BASE_PATH } from 'karibu-layer';
-
-@NgModule({
-    imports: [],
-    declarations: [ AppComponent ],
-    providers: [ provide: BASE_PATH, useValue: 'https://your-web-service.com' ],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
-
-### Using @angular/cli
-
-First extend your `src/environments/*.ts` files by adding the corresponding base path:
+// with factory building a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi, Configuration } from 'karibu-layer';
 
-```typescript
-export const environment = {
-  production: false,
-  API_BASE_PATH: 'http://127.0.0.1:8080'
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        {
+            provide: Configuration,
+            useFactory: (authService: AuthService) => new Configuration({
+                    basePath: 'http://localhost:9999',
+                    withCredentials: true,
+                    username: authService.getUsername(),
+                    password: authService.getPassword(),
+            }),
+            deps: [AuthService],
+            multi: false
+        }
+    ],
 };
 ```
 
-In the src/app/app.module.ts:
+### Using multiple OpenAPI files / APIs
+
+In order to use multiple APIs generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
 
 ```typescript
-import { BASE_PATH } from 'karibu-layer';
+import { provideApi as provideUserApi } from 'my-user-api-path';
+import { provideApi as provideAdminApi } from 'my-admin-api-path';
+import { HttpClientModule } from '@angular/common/http';
 import { environment } from '../environments/environment';
 
-@NgModule({
-  declarations: [
-    AppComponent
-  ],
-  imports: [ ],
-  providers: [{ provide: BASE_PATH, useValue: environment.API_BASE_PATH }],
-  bootstrap: [ AppComponent ]
-})
-export class AppModule { }
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideUserApi(environment.basePath),
+        provideAdminApi(environment.basePath),
+    ],
+};
 ```
 
 ### Customizing path parameter encoding

package/api/api.d.ts

@@ -1,25 +1,21 @@
+export * from './app.service';
+import { AppService } from './app.service';
 export * from './authentication.service';
 import { AuthenticationService } from './authentication.service';
-export * from './board.service';
-import { BoardService } from './board.service';
-export * from './category.service';
-import { CategoryService } from './category.service';
-export * from './establishment.service';
-import { EstablishmentService } from './establishment.service';
-export * from './establishmentAccessor.service';
-import { EstablishmentAccessorService } from './establishmentAccessor.service';
-export * from './invoice.service';
-import { InvoiceService } from './invoice.service';
-export * from './order.service';
-import { OrderService } from './order.service';
-export * from './orderItem.service';
-import { OrderItemService } from './orderItem.service';
-export * from './payment.service';
-import { PaymentService } from './payment.service';
-export * from './product.service';
-import { ProductService } from './product.service';
-export * from './role.service';
-import { RoleService } from './role.service';
-export * from './user.service';
-import { UserService } from './user.service';
-export declare const APIS: (typeof AuthenticationService | typeof BoardService | typeof CategoryService | typeof EstablishmentService | typeof EstablishmentAccessorService | typeof InvoiceService | typeof OrderService | typeof OrderItemService | typeof PaymentService | typeof ProductService | typeof RoleService | typeof UserService)[];
+export * from './boards.service';
+import { BoardsService } from './boards.service';
+export * from './categories.service';
+import { CategoriesService } from './categories.service';
+export * from './establishments.service';
+import { EstablishmentsService } from './establishments.service';
+export * from './invoices.service';
+import { InvoicesService } from './invoices.service';
+export * from './orders.service';
+import { OrdersService } from './orders.service';
+export * from './payments.service';
+import { PaymentsService } from './payments.service';
+export * from './products.service';
+import { ProductsService } from './products.service';
+export * from './users.service';
+import { UsersService } from './users.service';
+export declare const APIS: (typeof AppService | typeof AuthenticationService | typeof BoardsService | typeof CategoriesService | typeof EstablishmentsService | typeof InvoicesService | typeof OrdersService | typeof PaymentsService | typeof ProductsService | typeof UsersService)[];

package/api/app.service.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export declare class AppService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    appControllerGetHello(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    appControllerGetHello(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    appControllerGetHello(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}

package/api/authentication.service.d.ts

@@ -1,9 +1,8 @@
 import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { LoginRequestDTO } from '../model/loginRequestDTO';
-import { LoginResponseDTO } from '../model/loginResponseDTO';
-import { TokenRequest } from '../model/tokenRequest';
-import { TokenResponse } from '../model/tokenResponse';
+import { AuthResponseDto } from '../model/authResponseDto';
+import { LoginDto } from '../model/loginDto';
+import { RegisterDto } from '../model/registerDto';
 import { Configuration } from '../configuration';
 import { BaseService } from '../api.base.service';
 import * as i0 from "@angular/core";
@@ -11,129 +10,127 @@ export declare class AuthenticationService extends BaseService {
     protected httpClient: HttpClient;
     constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
     /**
-     * Authentification dédiée pour les administrateurs
-     * @param loginRequestDTO
+     * Supprimer un utilisateur
+     * @param id ID de l\'utilisateur
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    authControllerDeleteUser(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<LoginResponseDTO>;
-    adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<any>;
+    authControllerDeleteUser(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpResponse<LoginResponseDTO>>;
-    adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<HttpResponse<any>>;
+    authControllerDeleteUser(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpEvent<LoginResponseDTO>>;
+    }): Observable<HttpEvent<any>>;
     /**
-     * Génère un token avec droits admin (protégé)
-     * @param tokenRequest
+     * Verrouiller un compte utilisateur
+     * @param id ID de l\&#39;utilisateur
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    generateAdminToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    authControllerLockUser(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<TokenResponse>;
-    generateAdminToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<any>;
+    authControllerLockUser(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpResponse<TokenResponse>>;
-    generateAdminToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<HttpResponse<any>>;
+    authControllerLockUser(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpEvent<TokenResponse>>;
+    }): Observable<HttpEvent<any>>;
     /**
-     * Génère un token personnalisé pour un utilisateur
-     * @param tokenRequest
+     * Login user
+     * @param loginDto
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    generateCustomToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {
+    authControllerLogin(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<TokenResponse>;
-    generateCustomToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {
+    }): Observable<AuthResponseDto>;
+    authControllerLogin(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpResponse<TokenResponse>>;
-    generateCustomToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {
+    }): Observable<HttpResponse<AuthResponseDto>>;
+    authControllerLogin(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpEvent<TokenResponse>>;
+    }): Observable<HttpEvent<AuthResponseDto>>;
     /**
-     * Génère un token avec des claims personnalisés
-     * @param tokenRequest
-     * @param role
-     * @param establishmentAccess
+     * Validate user account
+     * @param email
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    authControllerReSendValidationEmail(email: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<TokenResponse>;
-    generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<any>;
+    authControllerReSendValidationEmail(email: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpResponse<TokenResponse>>;
-    generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json';
+    }): Observable<HttpResponse<any>>;
+    authControllerReSendValidationEmail(email: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpEvent<TokenResponse>>;
+    }): Observable<HttpEvent<any>>;
     /**
-     * Authentification et génération d\&#39;un token selon le rôle
-     * @param loginRequestDTO
+     * Register a new user
+     * @param registerDto
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    login(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {
+    authControllerRegister(registerDto: RegisterDto, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<LoginResponseDTO>;
-    login(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {
+    }): Observable<AuthResponseDto>;
+    authControllerRegister(registerDto: RegisterDto, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpResponse<LoginResponseDTO>>;
-    login(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {
+    }): Observable<HttpResponse<AuthResponseDto>>;
+    authControllerRegister(registerDto: RegisterDto, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
-    }): Observable<HttpEvent<LoginResponseDTO>>;
+    }): Observable<HttpEvent<AuthResponseDto>>;
     /**
-     * Révoque tous les tokens d\&#39;un utilisateur (déconnexion forcée)
-     * @param uid
+     * Déverrouiller un compte utilisateur
+     * @param id ID de l\&#39;utilisateur
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      */
-    revokeTokens(uid: string, observe?: 'body', reportProgress?: boolean, options?: {
+    authControllerUnlockUser(id: number, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<any>;
-    revokeTokens(uid: string, observe?: 'response', reportProgress?: boolean, options?: {
+    authControllerUnlockUser(id: number, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<HttpResponse<any>>;
-    revokeTokens(uid: string, observe?: 'events', reportProgress?: boolean, options?: {
+    authControllerUnlockUser(id: number, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: undefined;
         context?: HttpContext;
         transferCache?: boolean;