@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/{Poi.js → Poi.ts}

@@ -1,12 +1,14 @@
 import { ApiError } from "../error.js";
-import BaseEntity from "./BaseEntity.js";
+import { BaseEntity } from "./BaseEntity.js";
 
-export class Poi extends BaseEntity {
-  static entityType = "poi";
+import type { AddPoiData } from "./EndpointApi.types.js";
 
-  static entityTag = "Poi";
+export class Poi extends BaseEntity<any> {
+  static override entityType = "poi";
 
-  static SCHEMA_CONSTANTS = [
+  static override entityTag = "Poi";
+
+  static override SCHEMA_CONSTANTS: string[] = [
     "ADD_POI",
     "UPDATE_BLOCK_DESCRIPTION",
     "UPDATE_BLOCK_INFO",
@@ -18,7 +20,7 @@ export class Poi extends BaseEntity {
   static ADD_BLOCKS = new Map([
     ["ADD_POI", "addPoi"],
     ["PROFIL_IMAGE", "updateImageProfil"]
-  ]);
+  ] as const);
 
   static UPDATE_BLOCKS = new Map([
     ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
@@ -26,29 +28,29 @@ export class Poi extends BaseEntity {
     ["UPDATE_BLOCK_INFO", "updateInfo"],
     ["UPDATE_BLOCK_SLUG", "updateSlug"],
     ["PROFIL_IMAGE", "updateImageProfil"]
-  ]);
+  ] as const);
 
-  defaultFields = {
+  override defaultFields: Record<string, any> = {
     typeElement: this.getEntityType()
   };
 
-  removeFields = [
+  override removeFields: string[] = [
     "typeElement"
   ];
 
-  transforms = {
+  // transforms = {
 
-  };
+  // };
 
-  async _add(payload) {
+  override _add = async (payload: Record<string, any>): Promise<void> => {
     if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _add, utilisez save");
+      throw new ApiError("utilisation invalide de _add, utilisez save", 400);
     }
 
     payload.id = this._newId?.();
     if (payload.slug) delete payload.slug;
 
-    for (const [constant, methodName] of Poi.ADD_BLOCKS) {
+    for (const [constant, methodName] of Array.from(Poi.ADD_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
         constant,
@@ -56,27 +58,27 @@ export class Poi extends BaseEntity {
         () => {}
       );
       if (blockData && Object.keys(blockData).length > 0) {
-        const data = await this[methodName](blockData);
+        const data = await this._invokeBlockMethod(Poi.ADD_BLOCKS, methodName, blockData);
         if (!this.id && data?.map?.id) {
           this._draftData.id = data.map.id;
           this._draftData.slug = data.map.slug;
         }
       }
     }
-  }
+  };
 
-  async _update(payload) {
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
     if(!this.isAuthor()){
       throw new ApiError("Vous n'avez pas les droits pour modifier ce POI", 403);
     }
     if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _update, utilisez save");
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
     }
 
     if (payload.id) delete payload.id;
     let hasChanged = false;
 
-    for (const [constant, methodName] of Poi.UPDATE_BLOCKS) {
+    for (const [constant, methodName] of Array.from(Poi.UPDATE_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
         constant,
@@ -85,100 +87,106 @@ export class Poi extends BaseEntity {
         this.removeFields
       );
       if (blockData && Object.keys(blockData).length > 0) {
-        await this[methodName](blockData);
+        await this._invokeBlockMethod(Poi.UPDATE_BLOCKS, methodName, blockData);
         hasChanged = true;
       }
     }
 
     return hasChanged;
-  }
+  };
 
-  async addPoi(data = {}) {
+  async addPoi(data: Partial<AddPoiData> = {}): Promise<unknown> {
 
-    if (!this.isMe) {
-      data.parent = {};
-      data.parent[`${this.parent.id}`] = {
+    if (!this.isMe && this.parent) {
+      (data as any).parent = {};
+      (data as any).parent[`${this.parent.id}`] = {
         type: this.parent.getEntityType(),
-        name: this.parent.name
+        name: (this.parent as any).name
       };
     }
 
-    return this.callIsConnected(() => this.endpointApi.addPoi(data));
+    return this.callIsConnected(() => this.endpointApi.addPoi(data as AddPoiData));
   }
 
-  async getOrganizations() {
-    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`);
+  override async getOrganizations(): Promise<never> {
+    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getProjects() {
-    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`);
+  override async getProjects(): Promise<never> {
+    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getEvents() {
-    throw new ApiError(`getEvents n'existe pas dans${this.constructor.name}`);
+  async getEvents(): Promise<never> {
+    throw new ApiError(`getEvents n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getPois() {
-    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`);
+  override async getPois(): Promise<never> {
+    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getBadgesIssuer() {
-    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`);
+  override async getBadgesIssuer(): Promise<never> {
+    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getNews(data = {}) {
+  /**
+   * {@inheritDoc BaseEntity#getNews}
+   *
+   * Récupère les actualités du POI.
+   */
+  override async getNews(data: Parameters<BaseEntity<any>["getNews"]>[0] = {}) {
     return super.getNews(data);
   }
 
-  async getSubscribers(data = {}) {
+  /**
+   * {@inheritDoc BaseEntity#getSubscribers}
+   *
+   * Récupère les abonnés du POI.
+   */
+  override async getSubscribers(data: Parameters<BaseEntity<any>["getSubscribers"]>[0] = {}) {
     return super.getSubscribers(data);
   }
 
-  async project() {
-    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`);
+  override async project(): Promise<never> {
+    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async poi() {
-    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`);
+  override async poi(): Promise<never> {
+    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async event() {
-    throw new ApiError(`event n'existe pas dans ${this.constructor.name}`);
+  override async event(): Promise<never> {
+    throw new ApiError(`event n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async badge() {
-    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`);
+  override async badge(): Promise<never> {
+    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`, 501);
   }
 
   /**
+   * {@inheritDoc BaseEntity#news}
+   *
    * Crée une instance de news et la récupère si nécessaire.
-   * 
-   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
-   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
-   * @throws {ApiError} Si une erreur se produit lors de la création de la news.
    */
-  async news(newsData = {}) {
+  override async news(newsData: Parameters<BaseEntity<any>["news"]>[0] = {}) {
     return super.news(newsData);
   }
 
   /**
+   * {@inheritDoc BaseEntity#follow}
+   *
    * Suivre un POI.
    * Cette action permet à l'utilisateur de suivre un POI.
-   * 
-   * @returns {Promise<Object>} - Résultat de l'action de suivi.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
    */
-  async follow() {
+  override async follow() {
     return super.follow();
   }
 
   /**
+   * {@inheritDoc BaseEntity#unfollow}
+   *
    * Se désabonne d'un POI.
-   * 
-   * @returns {Promise<Object>} - Résultat de la désinscription.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
    */
-  async unfollow() {
+  override async unfollow() {
     return super.unfollow();
   }