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

package/lib/tus.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tus = void 0;
+const core_1 = require("./core");
+const tus_js_client_1 = require("tus-js-client");
+class Tus extends core_1.Core {
+    constructor(config, client) {
+        super(config, client);
+    }
+    upload(file, errorFn, chunckFn, successFn) {
+        const upload = new tus_js_client_1.Upload(file, {
+            endpoint: this.config.metarisc_url + '/resumable-file-uploads/files',
+            retryDelays: [0, 3000, 6000, 9000, 12000],
+            chunkSize: 1024 * 512,
+            metadata: {
+                fileName: file.name,
+                filetype: file.type,
+            },
+            headers: {
+                Authorization: this.client.getAccessToken() ?? '',
+            },
+            onError: (error) => {
+                errorFn(error);
+            },
+            onChunkComplete: (chunkSize, bytesAccepted, bytesTotal) => {
+                const progress = Math.floor((bytesAccepted * 100) / bytesTotal);
+                const url = upload.url;
+                chunckFn(url, progress);
+            },
+            onSuccess: () => {
+                successFn();
+            },
+        });
+        upload.start();
+    }
+    download(fileId) {
+        return this.request({
+            method: "GET",
+            endpoint: "/resumable-file-uploads/files/" + fileId
+        });
+    }
+}
+exports.Tus = Tus;

package/lib/utils.d.ts

@@ -0,0 +1,8 @@
+export default class Utils {
+    /**
+     * Build URL with query params templates
+     */
+    static constructPath(data: {
+        [key: string]: string;
+    }, url: string): string;
+}

package/lib/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Utils {
+    /**
+     * Build URL with query params templates
+     */
+    static constructPath(data, url) {
+        const r = RegExp('{([^}]*)}', 'g');
+        let s = '';
+        let idx = 0;
+        for (let a; (a = r.exec(url)) !== null;) {
+            s += (url.substring(idx, r.lastIndex - a[0].length) + data[a[1]]);
+            idx = r.lastIndex;
+        }
+        if (idx < url.length) {
+            s += url.substring(idx, url.length);
+        }
+        return s;
+    }
+}
+exports.default = Utils;

package/package.json

@@ -1,20 +1,27 @@
 {
-    "name": "@metarisc/metarisc-js",
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
-    "version": "0.0.1-alpha.2",
-    "scripts": {
-        "lint": "eslint . --ext .ts",
-        "compile": "tsc"
-    },
-    "devDependencies": {
-        "@types/node": "^18.14.4",
-        "@typescript-eslint/eslint-plugin": "^5.54.0",
-        "@typescript-eslint/parser": "^5.54.0",
-        "eslint": "^8.35.0",
-        "typescript": "^4.9.5"
-    },
-    "dependencies": {
-        "axios": "^1.4.0"
-    }
+  "name": "@metarisc/metarisc-js",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "version": "0.0.1-alpha.21",
+  "scripts": {
+    "lint": "eslint . --ext .ts --fix",
+    "compile": "tsc",
+    "tests": "npm run compile && node tests/index.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^18.14.4",
+    "@typescript-eslint/eslint-plugin": "^6.7.5",
+    "@typescript-eslint/parser": "^6.7.5",
+    "eslint": "^8.35.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "axios": "^1.4.0",
+    "axios-cache-interceptor": "^1.3.2",
+    "axios-oauth-client": "^2.0.4",
+    "axios-retry": "^3.5.0",
+    "tus-js-client": "^3.1.1"
+  }
 }

package/src/api/DossiersAPI.ts

@@ -0,0 +1,155 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { Dossier } from '../model/Dossier';
+import { PostDossierRequest } from '../model/PostDossierRequest';
+import { Workflow } from '../model/Workflow';
+import { Tag } from '../model/Tag';
+import { Document } from '../model/Document';
+
+export class DossiersAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération de l'ensemble des données d'un dossier.
+     * @param dossierId Identifiant unique du Dossier
+     */
+    async getDossier(dossierId: string): Promise<AxiosResponse<Dossier>>
+    {
+        const pathVariable = { 'dossier_id': dossierId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération des détails d'un workflow.
+     * @param dossierId Identifiant unique du Dossier
+     * @param workflowId Identifiant unique du Workflow
+     */
+    async getDossierWorkflowsDetails(dossierId: string, workflowId: string): Promise<AxiosResponse<Workflow>>
+    {
+        const pathVariable = { 'dossier_id': dossierId, 'workflow_id': workflowId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}/workflows/{workflow_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des tags d'un dossier.
+     * @param dossierId Identifiant unique du Dossier
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateDossierTags(dossierId: string, page?: number, perPage?: number): Collection<Tag>
+    {
+        const pathVariable = { 'dossier_id': dossierId };
+        return this.collect<Tag>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}/tags'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Liste des documents liés à un workflow.
+     * @param dossierId Identifiant unique du Dossier
+     * @param workflowId Identifiant unique du Workflow
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateDossierWorkflowDocuments(dossierId: string, workflowId: string, page?: number, perPage?: number): Collection<Document>
+    {
+        const pathVariable = { 'dossier_id': dossierId, 'workflow_id': workflowId };
+        return this.collect<Document>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}/workflows/{workflow_id}/documents'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des workflows d'un dossier.
+     * @param dossierId Identifiant unique du Dossier
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateDossierWorkflows(dossierId: string, page?: number, perPage?: number): Collection<Workflow>
+    {
+        const pathVariable = { 'dossier_id': dossierId };
+        return this.collect<Workflow>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}/workflows'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des dossiers selon des critères de recherche.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateDossiers(page?: number, perPage?: number): Collection<Dossier>
+    {
+        const pathVariable = {  };
+        return this.collect<Dossier>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * TODO : Modification d'un dossier existant.
+     * @param dossierId Identifiant unique du Dossier
+     * @param dossier 
+     */
+    async patchDossier(dossierId: string, dossier?: Dossier): Promise<AxiosResponse<Dossier>>
+    {
+        const pathVariable = { 'dossier_id': dossierId };
+        return this.request({
+            method: 'PATCH',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers/{dossier_id}'),
+            headers: {  },
+            params: {  },
+            body:  { 'id': dossier?.id, 'type': dossier?.type, 'description': dossier?.description, 'date_de_creation': dossier?.date_de_creation, 'createur': dossier?.createur, 'application_utilisee': dossier?.application_utilisee, 'statut': dossier?.statut } 
+        });
+    }
+    
+    /**
+     * TODO : Création d'un nouveau dossier.
+     * @param postDossierRequest 
+     */
+    async postDossier(postDossierRequest?: PostDossierRequest): Promise<AxiosResponse<Dossier>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'POST',
+            endpoint: Utils.constructPath(pathVariable, '/dossiers'),
+            headers: {  },
+            params: {  },
+            body:  { 'titre': postDossierRequest?.titre, 'description': postDossierRequest?.description, 'workflows': postDossierRequest?.workflows } 
+        });
+    }
+    
+}

package/src/api/EvenementsAPI.ts

@@ -0,0 +1,101 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { Evenement } from '../model/Evenement';
+import { PostEvenementRequest } from '../model/PostEvenementRequest';
+import { Utilisateur } from '../model/Utilisateur';
+
+export class EvenementsAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Suppression d'un événement correspondant à l'id donné.
+     * @param evenementId Identifiant unique de l'Événement
+     */
+    async deleteEvenement(evenementId: string): Promise<AxiosResponse<void>>
+    {
+        const pathVariable = { 'evenement_id': evenementId };
+        return this.request({
+            method: 'DELETE',
+            endpoint: Utils.constructPath(pathVariable, '/evenements/{evenement_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération des détails d'un événement correspondant à l'id donné.
+     * @param evenementId Identifiant unique de l'Événement
+     * @param evenement 
+     */
+    async getEvenementDetails(evenementId: string, evenement?: Evenement): Promise<AxiosResponse<Evenement>>
+    {
+        const pathVariable = { 'evenement_id': evenementId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/evenements/{evenement_id}'),
+            headers: {  },
+            params: {  },
+            body:  { 'id': evenement?.id, 'title': evenement?.title, 'type': evenement?.type, 'description': evenement?.description, 'date_debut': evenement?.date_debut, 'date_fin': evenement?.date_fin } 
+        });
+    }
+    
+    /**
+     * Récupération d'une liste paginée d'utilisateurs liés à un événement calendaire.
+     * @param evenementId Identifiant unique de l'Événement
+     * @param page Le numéro de la page.
+     * @param perPage Limite le nombre d'objets retournés. La limite est comprise entre 1 et 100, la valeur par défaut étant de 10.
+     */
+    paginateEvenementUtilisateurs(evenementId: string, page?: number, perPage?: number): Collection<Utilisateur>
+    {
+        const pathVariable = { 'evenement_id': evenementId };
+        return this.collect<Utilisateur>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/evenements/{evenement_id}/utilisateurs'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération des détails de tous les événements calendaires existants.
+     * @param page Le numéro de la page.
+     * @param perPage Limite le nombre d'objets retournés. La limite est comprise entre 1 et 100, la valeur par défaut étant de 10.
+     * @param type Le type d'événement 
+     * @param period la période (ISO 8601) séparée par un slash (/) pendant laquelle l'événement se déroule. Exemple 2004-12-02T23:00/2005-01-01T12:30
+     */
+    paginateEvenements(page?: number, perPage?: number, type?: string, period?: string): Collection<Evenement>
+    {
+        const pathVariable = {  };
+        return this.collect<Evenement>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/evenements'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString(), 'type': type, 'period': period },
+            body: {}
+        });
+    }
+    
+    /**
+     * TODO : Création d'un événement.
+     * @param postEvenementRequest 
+     */
+    async postEvenement(postEvenementRequest?: PostEvenementRequest): Promise<AxiosResponse<Evenement>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'POST',
+            endpoint: Utils.constructPath(pathVariable, '/evenements'),
+            headers: {  },
+            params: {  },
+            body:  { 'title': postEvenementRequest?.title, 'type': postEvenementRequest?.type, 'description': postEvenementRequest?.description, 'date_debut': postEvenementRequest?.date_debut, 'date_fin': postEvenementRequest?.date_fin } 
+        });
+    }
+    
+}

package/src/api/NotificationsAPI.ts

@@ -0,0 +1,79 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { Notification } from '../model/Notification';
+import { PostNotificationRequest } from '../model/PostNotificationRequest';
+
+export class NotificationsAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Suppression d'une notification correspondante à l'id donné.
+     * @param notificationId Identifiant unique de la Notification
+     */
+    async deleteNotification(notificationId: string): Promise<AxiosResponse<void>>
+    {
+        const pathVariable = { 'notification_id': notificationId };
+        return this.request({
+            method: 'DELETE',
+            endpoint: Utils.constructPath(pathVariable, '/notifications/{notification_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération des détails d'une notification correspondante à l'id donné.
+     * @param notificationId Identifiant unique de la Notification
+     */
+    async getNotification(notificationId: string): Promise<AxiosResponse<Notification>>
+    {
+        const pathVariable = { 'notification_id': notificationId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/notifications/{notification_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération des détails de toutes les notifications existantes pour l'utilisateur connecté.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateNotifications(page?: number, perPage?: number): Collection<Notification>
+    {
+        const pathVariable = {  };
+        return this.collect<Notification>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/notifications'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Création d'une notification.
+     * @param postNotificationRequest 
+     */
+    async postNotification(postNotificationRequest?: PostNotificationRequest): Promise<AxiosResponse<Notification>>
+    {
+        const pathVariable = {  };
+        return this.request({
+            method: 'POST',
+            endpoint: Utils.constructPath(pathVariable, '/notifications'),
+            headers: {  },
+            params: {  },
+            body:  { 'title': postNotificationRequest?.title, 'message': postNotificationRequest?.message, 'contexte': postNotificationRequest?.contexte, 'utilisateur_id': postNotificationRequest?.utilisateur_id } 
+        });
+    }
+    
+}

package/src/api/OrganisationAPI.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 { Organisation } from '../model/Organisation';
+
+export class OrganisationAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération des détails d'une organisation.
+     * @param orgId ID de l'organisation
+     */
+    async getOrganisation(orgId: string): Promise<AxiosResponse<Organisation>>
+    {
+        const pathVariable = { 'org_id': orgId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/organisations/{org_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Liste paginée des organisations.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateOrganisations(page?: number, perPage?: number): Collection<Organisation>
+    {
+        const pathVariable = {  };
+        return this.collect<Organisation>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/organisations/'),
+            headers: {  },
+            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            body: {}
+        });
+    }
+    
+}

package/src/api/OrganisationsAPI.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 { Organisation } from '../model/Organisation';
+
+export class OrganisationsAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération des détails d'une organisation.
+     * @param orgId Identifiant unique de l'Organisation
+     */
+    async getOrganisation(orgId: string): Promise<AxiosResponse<Organisation>>
+    {
+        const pathVariable = { 'org_id': orgId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/organisations/{org_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Liste paginée des organisations.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginateOrganisations(page?: number, perPage?: number): Collection<Organisation>
+    {
+        const pathVariable = {  };
+        return this.collect<Organisation>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/organisations'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+}

package/src/api/PEIAPI.ts

@@ -0,0 +1,103 @@
+import { Core, MetariscConfig } from "../core";
+import Utils from "../utils";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Collection } from "../collection";
+import { PEI } from '../model/PEI';
+import { Contact } from '../model/Contact';
+import { DescriptifTechnique } from '../model/DescriptifTechnique';
+import { PieceJointe } from '../model/PieceJointe';
+
+export class PEIAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client) {
+        super(config, client);
+    }
+    
+    /**
+     * Récupération de l'ensemble des données d'un PEI.
+     * @param peiId Identifiant unique du PEI
+     */
+    async getPei(peiId: string): Promise<AxiosResponse<PEI>>
+    {
+        const pathVariable = { 'pei_id': peiId };
+        return this.request({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/pei/{pei_id}'),
+            headers: {  },
+            params: {  },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des Points d'Eau Incendie (PEI) selon des critères de recherche.
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePei(page?: number, perPage?: number): Collection<PEI>
+    {
+        const pathVariable = {  };
+        return this.collect<PEI>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/pei'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des contacts d'un Point d'Eau Incendie.
+     * @param peiId Identifiant unique du PEI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePeiContacts(peiId: string, page?: number, perPage?: number): Collection<Contact>
+    {
+        const pathVariable = { 'pei_id': peiId };
+        return this.collect<Contact>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/pei/{pei_id}/contacts'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de l'historique d'un POI.
+     * @param peiId Identifiant unique du PEI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePeiHistorique(peiId: string, page?: number, perPage?: number): Collection<DescriptifTechnique>
+    {
+        const pathVariable = { 'pei_id': peiId };
+        return this.collect<DescriptifTechnique>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/pei/{pei_id}/historique'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+    /**
+     * Récupération de la liste des pièces jointes d'un Point d'Eau Incendie.
+     * @param peiId Identifiant unique du PEI
+     * @param page Numéro de page
+     * @param perPage Nombre de résultats demandé
+     */
+    paginatePeiPiecesJointes(peiId: string, page?: number, perPage?: number): Collection<PieceJointe>
+    {
+        const pathVariable = { 'pei_id': peiId };
+        return this.collect<PieceJointe>({
+            method: 'GET',
+            endpoint: Utils.constructPath(pathVariable, '/pei/{pei_id}/pieces_jointes'),
+            headers: {  },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
+            body: {}
+        });
+    }
+    
+}