@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/News.ts

@@ -0,0 +1,331 @@
+import { ApiError, ApiResponseError } from "../error.js";
+import { BaseEntity } from "./BaseEntity.js";
+
+import type { Comment } from "./Comment.js";
+import type { AddNewsData, UpdateNewsData, DeleteNewsData, AddImageNewsData, AddFileNewsData, GetCommentsData } from "./EndpointApi.types.js";
+import type { NewsItemNormalized } from "./serverDataType/News.js";
+
+export class News extends BaseEntity<NewsItemNormalized> {
+  static override entityType = "news";
+
+  static override entityTag = "News";
+
+  static override SCHEMA_CONSTANTS: string[] = [
+    "ADD_NEWS"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_NEWS", "addNews"]
+  ] as const);
+
+  static UPDATE_BLOCKS = new Map([
+    ["ADD_NEWS", "updateNews"]
+  ] as const);
+
+  override defaultFields: Record<string, any> = {};
+
+  override removeFields: string[] = ["parentId", "parentType"];
+
+  override transforms: {
+    scope: (val: any) => any;
+    mentions: (val: any) => any[];
+    mediaImg: (val: any) => {
+      countImages: number;
+      images: string[];
+    };
+    mediaFile: (val: any) => {
+      countFiles: number;
+      files: any[];
+    };
+  } = {
+      scope: val => val?.type,
+      mentions: val =>
+        Array.isArray(val)
+          ? val.map(m => ({ ...m, count: parseInt(m.count) }))
+          : [],
+      mediaImg: val => {
+        const images = val?.images?.map((img: any) => img.id).filter(Boolean) || [];
+        return images.length > 0 ? { countImages: images.length, images } : { countImages: 0, images: [] };
+      },
+      mediaFile: val => {
+        const files = val?.files?.map((f: any) => f.id).filter(Boolean) || [];
+        return files.length > 0 ? { countFiles: files.length, files } : { countFiles: 0, files: [] };
+      }
+    };
+
+  /**
+   * Transforme les champs imbriqués (author, target, sharedBy, etc.) en instances d'entités.
+   * @param data - Les données brutes du serveur.
+   * @returns Les données transformées.
+   * @protected
+   */
+  protected override _transformServerData(data: NewsItemNormalized): NewsItemNormalized {
+    // Transformer author en instance User/Organization
+    if (data.author) {
+      data.author = this._linkNestedEntity(data.author);
+    }
+
+    // Transformer target en instance User/Organization/Project
+    if (data.target) {
+      data.target = this._linkNestedEntity(data.target);
+    }
+
+    // Transformer lastAuthorShare en instance
+    if (data.lastAuthorShare) {
+      data.lastAuthorShare = this._linkNestedEntity(data.lastAuthorShare);
+    }
+
+    // Transformer le tableau sharedBy
+    if (Array.isArray(data.sharedBy)) {
+      data.sharedBy = data.sharedBy.map(item => this._linkNestedEntity(item));
+    }
+
+    return data;
+  }
+
+  /**
+   * Récupérer des actualités par IDs : Récupère des actualités à partir d'une liste d'identifiants.
+   * Constant : GET_NEWS_BY_ID
+   */
+  override async get(): Promise<Record<string, any>> {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.", 400);
+    const id = this.id; // Type narrowing
+
+    const newsArray = await this.callIsConnected(() =>
+      this.endpointApi.getNewsById({ ids: [id] })
+    );
+    
+    if (newsArray && Array.isArray(newsArray) && newsArray.length === 1) {
+      const data = newsArray[0];
+      this._setData(data, { forceInitialDraftReset: true });
+      return this.serverData;
+    }
+    throw new ApiError(`Aucune actualité trouvée pour l'ID ${this.id}`, 404);
+  }
+
+
+  override _add = async (payload: Record<string, any>): Promise<void> => {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _add, utilisez save");
+    }
+
+    // si le texte est vide, on met un espace pour que le champ soit pris en compte car sur le serveur
+    // il y a une vérification de la taille du texte je pense
+    if(payload.text === ""){
+      payload.text = " ";
+    }
+    if (this.parent) {
+      payload.parentId = this.parent.id;
+      payload.parentType = this.parent.getEntityType();
+    }
+    
+    // const data = await this.callIsConnected(() => this.endpointApi.addNews(payload));
+    // this._draftData.id = data.object.id;
+    // // TODO : voir si j'ai ce qui faut dans reponseData de ADD_NEWS pour mettre à jour #serverData
+    // // c'est dans reponseData.object
+    // // if(data?.object){
+    // //   this._serverData = { ...data.object };
+    // // }
+    
+    for (const [constant, methodName] of Array.from(News.ADD_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {},
+        []
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this._invokeBlockMethod(News.ADD_BLOCKS, methodName, blockData);
+        if (!this.id && data?.object?.id) {
+          this._draftData.id = data.object.id;
+          // this._serverData = { ...data.object };
+        }
+      }
+    }
+  };
+
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _update, utilisez save");
+    }
+
+    if (payload.id) delete payload.id;
+
+    // si le texte est vide, on met un espace pour que le champ soit pris en compte car sur le serveur
+    // il y a une vérification de la taille du texte je pense
+    if(payload?.text === ""){
+      payload.text = " ";
+    }
+
+    if (this.parent) {
+      payload.parentId = this.parent.id;
+      payload.parentType = this.parent.getEntityType();
+    }
+    payload.idNews = this.id;
+
+    let hasChanged = false;
+    await this.callIsConnected(() => this.endpointApi.updateNews(payload as UpdateNewsData)) as any;
+    // TODO : voir si j'ai ce qui faut dans data de UPDATE_NEWS pour mettre à jour #serverData
+    // c'est dans data.object
+    // if(data?.object){
+    //   this._serverData = { ...data.object };
+    // }
+    hasChanged = true;
+    return hasChanged;
+  };
+
+  async addNews(data: Partial<AddNewsData> = {}): Promise<unknown> {
+    return this.callIsConnected(() => this.endpointApi.addNews(data as AddNewsData));
+  }
+
+  async updateNews(data: Partial<UpdateNewsData> = {}): Promise<unknown> {
+    return this.callIsConnected(() => this.endpointApi.updateNews(data as UpdateNewsData));
+  }
+
+  async addMention({ slug, id }: { slug?: string; id?: string; }): Promise<any[]> {
+    try {
+      if (!slug && !id) {
+        throw new ApiError("Vous devez fournir un slug ou un id pour ajouter une mention.", 400);
+      }
+
+      const userInstance = await this.entity("citoyens", { id, slug });
+      //   const userInstance = new this.deps.User(this.apiClient, { id, slug }, { EndpointApi: this.endpointApi  });
+      const user = userInstance.serverData;
+
+      if (!this._draftData.mentions) {
+        this._draftData.mentions = [];
+      }
+      // Vérification si la mention existe déjà
+      if (this._draftData.mentions.find((mention: any) => mention.id === user.id)) {
+        // Si la mention existe déjà, on incrémente le compteur
+        this._draftData.mentions = this._draftData.mentions.map((mention: any) => {
+          if (mention.id === user.id) {
+            mention.count += 1;
+          }
+          return mention;
+        });
+        return this._draftData.mentions;
+      }
+      const mention = { id: user.id, slug: user.slug, type: userInstance.getEntityType(), name: user.name, value:  user.name, count: 1 };
+      this._draftData.mentions.push(mention);
+      return this._draftData.mentions;
+    } catch (error) {
+      this.apiClient._logger.error("Erreur lors de l'ajout de la mention :", error);
+      throw error;
+    }
+
+  }
+
+  
+  /**
+   * Ajouter une image à une actualité : Ajoute une images à une actualité.
+   * Constant : ADD_IMAGE_NEWS
+   */
+  async addImage(image: File | Blob | Buffer | import("stream").Readable): Promise<{ id: string; [key: string]: any }> {
+    const validatedImage = await this._validateImage(image);
+    const data: AddImageNewsData = {
+      pathParams: {
+        folder: this.parent?.getEntityType() as "citoyens" | "projects" | "organizations",
+        ownerId: this.parent?.id as string
+      },
+      newsImage: validatedImage as any
+    };
+    const dataImage = await this.callIsConnected(() => this.endpointApi.addImageNews(data)) as { id: string; [key: string]: any };
+    if (this._draftData.mediaImg) {
+      this._draftData.mediaImg.countImages = this._draftData.mediaImg.countImages + 1;
+      this._draftData.mediaImg.images.push(dataImage.id);
+    } else {
+      this._draftData.mediaImg = { countImages: 1, images: [dataImage.id] };
+    }
+    return dataImage;
+  }
+
+  /**
+   * Ajouter un fichier à une actualité : Ajoute un fichier à une actualité.
+   * Constant : ADD_FILE_NEWS
+   */
+  async addFile(file: File | Blob | Buffer | import("stream").Readable): Promise<unknown> {
+    const validatedFile = await this._validateFile(file);
+    const data: AddFileNewsData = {
+      pathParams: {
+        folder: this.parent?.getEntityType() as "citoyens" | "projects" | "organizations",
+        ownerId: this.parent?.id as string
+      },
+      newsFile: validatedFile as any
+    };
+    const dataFile = await this.callIsConnected(() => this.endpointApi.addFileNews(data));
+    if (this._draftData.mediaFile) {
+      this._draftData.mediaFile.countFiles = this._draftData.mediaFile.countFiles + 1;
+      this._draftData.mediaFile.files.push(dataFile);
+    } else {
+      this._draftData.mediaFile = { countFiles: 1, files: [dataFile] };
+    }
+    return dataFile;
+  }
+
+  /**
+   * Supprimer une actualité : Supprime une actualité existante.
+   * Constant : DELETE_NEWS
+   */
+  async delete(): Promise<void> {
+    if(!this.id) {
+      throw new ApiError("Vous devez fournir un id pour supprimer une news.", 400);
+    }
+    const data = {
+      pathParams: { id: this.id },
+      isLive: false  // Valeur par défaut, peut être surchargée
+    };
+    await this.callIsConnected(() => this.endpointApi.deleteNews(data as DeleteNewsData));
+
+    // Vider les objets réactifs sans casser la réactivité
+    Object.keys(this._draftData).forEach(key => delete this._draftData[key]);
+    Object.keys(this._serverData).forEach(key => delete (this._serverData as any)[key]);
+
+    // Marquer comme supprimé
+    this._isDeleted = true;
+  }
+
+  /**
+   * Créer une instance de commentaire pour cette news.
+   * @param commentData - Données du commentaire.
+   * @returns Instance de Comment.
+   */
+  async comment(commentData: Record<string, any> = {}): Promise<Comment> {
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté.", 401);
+    }
+
+    const entity = await this.entity("comments", commentData);
+    return entity as Comment;
+  }
+
+  /**
+   * Récupérer les commentaires : Récupère la liste de commentaires selon plusieurs critères.
+   * Constant : GET_COMMENTS
+   * @returns - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async getComments(): Promise<Comment[]> {
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
+    }
+
+    const payload: GetCommentsData = {
+      pathParams: { type: "news", id: this.id },
+    };
+
+    const arrayObjet =  await this.endpointApi.getComments(payload);
+
+    if(!Array.isArray(arrayObjet)){
+      throw new ApiResponseError("Erreur lors de la récupération des commentaires.", 500, arrayObjet as object);
+    }
+
+    const rawList = this._linkEntities(arrayObjet);
+
+    return this._createFilteredProxy(rawList);
+  }
+
+}