@metarisc/metarisc-js 0.0.1-alpha.2 → 0.0.1-alpha.21

package/src/api/POIAPI.ts

@@ -0,0 +1,124 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { POI } from '../model/POI';
+import { PatchPoiRequest } from '../model/PatchPoiRequest';
+
+import { Contact } from '../model/Contact';
+
+import { DescriptifTechnique } from '../model/DescriptifTechnique';
+
+import { PieceJointe } from '../model/PieceJointe';
+
+export class POIAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération de l'ensemble des données d'un POI.
+     * @param poiId ID du POI
+     */
+    async getPoi(poiId: string): Promise<AxiosResponse<POI>>
+    {
+        const pathVariable = { 'poi_id': poiId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/poi/{poi_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des contacts d'un POI.
+     * @param poiId ID du POI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateContacts(poiId: string, page?: number, perPage?: number): Collection<Contact>
+    {
+        const pathVariable = { 'poi_id': poiId };
+        return this.collect<Contact>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/poi/{poi_id}/contacts'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de l'historique d'un POI.
+     * @param poiId ID du POI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateHistorique(poiId: string, page?: number, perPage?: number): Collection<DescriptifTechnique>
+    {
+        const pathVariable = { 'poi_id': poiId };
+        return this.collect<DescriptifTechnique>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/poi/{poi_id}/historique'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des pièces jointes d'un POI.
+     * @param poiId ID du POI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePiecesJointes(poiId: string, page?: number, perPage?: number): Collection<PieceJointe>
+    {
+        const pathVariable = { 'poi_id': poiId };
+        return this.collect<PieceJointe>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/poi/{poi_id}/pieces_jointes'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des POI selon des critères de recherche.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePoi(page?: number, perPage?: number): Collection<POI>
+    {
+        const pathVariable = {  };
+        return this.collect<POI>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/poi/'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Modifier un POI existant.
+     * @param poiId ID du POI
+     * @param patchPoiRequest 
+     */
+    async patchPoi(poiId: string, patchPoiRequest?: PatchPoiRequest): Promise<AxiosResponse<POI>>
+    {
+        const pathVariable = { 'poi_id': poiId };
+        return this.request({
+            method: 'PATCH',
+            endpoint: Utils.constructPath(pathVariable, '/poi/{poi_id}'),
+            headers: {  },
+            params: {  },
+            body:  { 'test': patchPoiRequest?.test } 
+        });
+    }
+    
+}

package/src/api/PingAPI.ts

@@ -0,0 +1,27 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Ping200Response } from '../model/Ping200Response';
+
+export class PingAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Permet de s'assurer que le service Metarisc est en ligne. Ping ... Pong !
+     */
+    async ping(): Promise<AxiosResponse<Ping200Response>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/ping'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+}

package/src/api/SupportAPI.ts

@@ -0,0 +1,63 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { PostTicketRequest } from '../model/PostTicketRequest';
+import { Ticket } from '../model/Ticket';
+
+export class SupportAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération des détails du ticket
+     * @param ticketId ID du ticket
+     */
+    async getTicket(ticketId: string): Promise<AxiosResponse<Ticket>>
+    {
+        const pathVariable = { 'ticket_id': ticketId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/support/{ticket_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des tickets de support.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateTickets(page?: number, perPage?: number): Collection<Ticket>
+    {
+        const pathVariable = {  };
+        return this.collect<Ticket>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/support/'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Création d'un nouveau ticket de support.
+     * @param postTicketRequest 
+     */
+    async postTicket(postTicketRequest?: PostTicketRequest): Promise<AxiosResponse<Ticket>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'POST',
+            endpoint: Utils.constructPath(pathVariable, '/support/'),
+            headers: {  },
+            params: {  },
+            body:  { 'subject': postTicketRequest?.subject, 'description': postTicketRequest?.description } 
+        });
+    }
+    
+}

package/src/api/UtilisateursAPI.ts

@@ -0,0 +1,46 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { Utilisateur } from '../model/Utilisateur';
+import { Email } from '../model/Email';
+
+export class UtilisateursAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * L'utilisateur connecté retourné par ce point de terminaison utilise le token d'accès généré par le service OpenID Connect afin de le lier à une identité connue de Metarisc. Si l'utilisateur est inconnu une erreur est retournée.
+     */
+    async getUtilisateursMoi(): Promise<AxiosResponse<Utilisateur>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/utilisateurs/@moi'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Liste toutes les adresses mail de l'utilisateur connecté, y compris les adresses non publiquement accessibles.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateMoiEmails(page?: number, perPage?: number): Collection<Email>
+    {
+        const pathVariable = {  };
+        return this.collect<Email>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/utilisateurs/@moi/emails'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+}

package/src/auth/oauth2.ts

@@ -0,0 +1,28 @@
+import { OAuth2Options } from "../core";
+
+export class OAuth2
+{
+    public static AUTHORIZATION_URL = 'https://lemur-17.cloud-iam.com/auth/realms/metariscoidc/protocol/openid-connect/auth';
+    public static ACCESS_TOKEN_URL  = 'https://lemur-17.cloud-iam.com/auth/realms/metariscoidc/protocol/openid-connect/token';
+ 
+    /**
+     * Utilisation d'OAuth2 pour récupérer un access token utilisable dans Metarisc.
+     *
+     * La configuration doit contenir au moins :
+     * - CLIENT_ID (Le client_id de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
+     * - CLIENT_SECRET (Le client_secret de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
+     *
+     * La configuration peut contenir aussi :
+     * - ACCESS_TOKEN_URL
+     **/
+
+    /**
+     * OAuth2 Authorize URL Generator helper.
+     */
+    public static authorizeUrl(options: OAuth2Options) : string
+    {
+        const params = new URLSearchParams(options);
+
+        return OAuth2.AUTHORIZATION_URL + '?' + params.toString();
+    }
+}

package/src/client.ts

@@ -0,0 +1,133 @@
+import axios, { AxiosInstance, AxiosResponse, RawAxiosRequestHeaders } from "axios";
+import axiosRetry from "axios-retry";
+import oauth from "axios-oauth-client";
+import { GrantResponse, MetariscConfig, OAuth2Options } from './core';
+import { OAuth2 } from "./auth/oauth2";
+import { setupCache } from 'axios-cache-interceptor';
+
+interface RequestConfig {
+  body?: any;
+  headers?: { [name: string]: string | string[] };
+  params?: { [param: string]: string | string[] };
+  endpoint?: string;
+  method?: string;
+}
+
+export enum AuthMethod {
+  CLIENT_CREDENTIALS,
+  AUTHORIZATION_CODE
+}
+
+export class Client {
+
+  private axios : AxiosInstance;
+
+  private access_token: string;
+
+  constructor(config : MetariscConfig) {
+    this.axios = axios.create({
+      baseURL: config.metarisc_url ?? 'https://api.metarisc.fr/',
+      'headers': {
+        'common': this.getDefaultHeaders()
+      }
+    });
+
+    // Axios Interceptors
+    // Request interceptors are FILO (First In Last Out)
+    // Response interceptors are FIFO (First In First Out)
+
+    // Axios interceptor : Enable HTTP Caching
+    // When combining axios-cache-interceptors with other interceptors, you may encounter some inconsistences.
+    // See : https://github.com/arthurfiorette/axios-cache-interceptor/issues/449#issuecomment-1370327566
+    this.axios = setupCache(this.axios);
+
+    // Axios interceptor : Retry strategy
+    axiosRetry(this.axios, {
+        retries: 3,
+        retryDelay: axiosRetry.exponentialDelay
+    });
+  }
+
+  async authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<GrantResponse> {
+    let result;
+    switch (auth_method) {
+      case AuthMethod.AUTHORIZATION_CODE:
+        result = await this.getAuthorizationCode(options);
+        break;
+      case AuthMethod.CLIENT_CREDENTIALS:
+        result = await this.getClientCredentials(options);
+        break;
+      default:
+        return;
+    }
+
+    if (result) {
+      const token = result.token_type + ' ' + result.access_token;
+      this.setAccessToken(token);
+    }
+
+    return result;
+  }
+
+  async request<T>(config: RequestConfig): Promise<AxiosResponse<T>> {
+    config.headers['Authorization'] = this.getAccessToken();
+    return this.axios.request<T>({
+      method: config.method || 'GET',
+      url: config.endpoint || '/',
+      params: config.params,
+      data: config.body,
+      headers: config.headers
+    });
+  }
+
+  async getAuthorizationCode(options: OAuth2Options): Promise<GrantResponse> {
+    const fn = oauth.authorizationCode(
+      axios.create(),
+      OAuth2.ACCESS_TOKEN_URL,
+      options.client_id ?? '',
+      options.client_secret ?? '',
+      options.redirect_uri ?? '',
+      options.code ?? '',
+      options.scope ?? ''
+    )
+    return await fn(options.code ?? '', options.scope ?? '')
+  }
+
+  async getClientCredentials(options: OAuth2Options): Promise<GrantResponse> {
+    const fn = oauth.clientCredentials(
+      axios.create(),
+      OAuth2.ACCESS_TOKEN_URL,
+      options.client_id ?? '',
+      options.client_secret ?? ''
+    )
+    return await fn(options.scope ?? '');
+  }
+
+  setAccessToken(access_token: string): void {
+    this.access_token = access_token;
+    this.axios.interceptors.request.use(function (config) {
+      config.headers['Authorization'] = access_token;
+      return config;
+    });
+  }
+
+  getAccessToken(): string {
+    return this.access_token;
+  }
+
+  /**
+   * Retourne les headers HTTP par défauts devant être présents dans toutes les requêtes Metarisc.
+   */
+  private getDefaultHeaders() : RawAxiosRequestHeaders
+  {
+    const headers : RawAxiosRequestHeaders = {};
+
+    // UA Headers
+    headers['User-Agent'] = 'MetariscJs/dev'; // Format User-Agent (https://www.rfc-editor.org/rfc/rfc9110#name-user-agent)
+    headers['Metarisc-User-Agent'] = JSON.stringify({
+      'lang': 'js'
+    });
+
+    return headers;
+  }
+}

package/src/collection.ts

@@ -0,0 +1,85 @@
+import { AxiosResponse } from "axios";
+import { Core } from "./core";
+
+export type PaginationResults<T> = {
+    data?: Array<T>;
+    meta?: {
+        pagination?: PaginationData;
+    };
+};
+
+export type PaginationData = {
+    total: number;
+    count: number;
+    per_page: number;
+    current_page: number;
+    total_pages: number;
+};
+
+type PaginationRequestConfig = {
+    headers ?: {[name: string]: string | string[]};
+    params ?: {[param: string]: string | string[]};
+    endpoint ?: string;
+};
+
+export class Collection<T>
+{
+    constructor(
+        private client : Core,
+        private config : PaginationRequestConfig
+    ) {}
+
+    /**
+     * Fetch current page results.
+     */
+    async fetchPage(page : number, per_page : number) : Promise<AxiosResponse<PaginationResults<T>>>
+    {
+        return this.client.request({
+            method: 'GET',
+            endpoint: this.config.endpoint,
+            headers: this.config.headers,
+            params: {...this.config.params, ...{
+                page: page.toString(),
+                per_page: per_page.toString()
+            }},  
+        });
+    }
+
+    /**
+     * Generates an iterator to automatically iterate over all pages in a result set.
+     */
+    async * autoPagingIterator() : AsyncGenerator<T, void, unknown>
+    {
+        let current_page : number = this.config.params && 'page' in this.config.params ? parseInt(this.config.params['page'].toString()) : 1;
+        const per_page : number = this.config.params && 'per_page' in  this.config.params ? parseInt(this.config.params['per_page'].toString()) : 100;
+
+        while (true) {
+            const response = <AxiosResponse<PaginationResults<T>>> await this.fetchPage(current_page, per_page);
+
+            for (const element of response.data.data) {
+                yield element;
+            }
+
+            if (response.data.meta.pagination.current_page === response.data.meta.pagination.total_pages) {
+                break;
+            }
+
+            current_page++;
+        }
+    }
+
+    /**
+     * Generates an array with all results set.
+     */
+    async autoPagingIteratorToArray() : Promise<Array<T>>
+    {
+        const generator = this.autoPagingIterator();
+        const results = [];
+
+        for await (const item of generator) {
+            results.push(item);
+        }
+
+        return results;
+    }
+}

package/src/core.ts

@@ -0,0 +1,70 @@
+import { AxiosResponse } from "axios";
+import { AuthMethod, Client } from "./client";
+import { Collection } from "./collection";
+
+interface RequestConfig {
+  body?: any;
+  headers?: { [name: string]: string | string[] };
+  params?: { [param: string]: string | string[] };
+  endpoint?: string;
+  method?: string;
+}
+
+export interface MetariscConfig {
+  metarisc_url?: string;
+}
+
+export interface OAuth2Options {
+  client_id?: string;
+  client_secret?: string;
+  response_type?: string;
+  redirect_uri?: string;
+  state?: string;
+  code?: string;
+  scope?: string;
+  [name: string]: string;
+}
+
+export interface GrantResponse {
+  access_token?: string;
+  expires_in?: number;
+  id_token?: string;
+  refresh_token?: string;
+  refresh_expires_in?: number;
+  session_state?: string;
+  token_type?: string;
+  error?: string;
+  error_description?: string;
+}
+
+export class Core {
+  protected client: Client;
+  protected config: MetariscConfig;
+
+  constructor(config: MetariscConfig, client?: Client) {
+    this.config = config;
+    this.client = client ?? new Client(config);
+  }
+
+    async request<T>(config : RequestConfig) : Promise<AxiosResponse<T>>
+    {
+        return this.client.request<T>(config);
+    }
+
+    collect<T>(config : RequestConfig) : Collection<T>
+    {
+        return new Collection<T>(this, {
+            endpoint: config.endpoint || '/',
+            params: config.params,
+            headers: config.headers
+        });
+    }
+
+    async authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<GrantResponse> {
+        return await this.client.authenticate(auth_method, options);
+    }
+
+    setAccessToken(access_token: string): void {
+        this.client.setAccessToken(access_token);
+    }
+}

package/src/index.ts

@@ -1 +1,22 @@
-export { Metarisc } from './metarisc';
+export { Metarisc } from "./metarisc";
+export { OAuth2 } from "./auth/oauth2";
+export { Core } from "./core";
+export { Collection } from "./collection";
+export { PaginationResults } from "./collection"
+export { AuthMethod } from "./client";
+export { Client } from "./client";
+export { Tus } from "./tus";
+
+export { DossiersAPI } from './api/DossiersAPI';
+
+export { EvenementsAPI } from './api/EvenementsAPI';
+
+export { NotificationsAPI } from './api/NotificationsAPI';
+
+export { OrganisationsAPI } from './api/OrganisationsAPI';
+
+export { PEIAPI } from './api/PEIAPI';
+
+export { PingAPI } from './api/PingAPI';
+
+export { UtilisateursAPI } from './api/UtilisateursAPI';