@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/Comment.ts

@@ -0,0 +1,200 @@
+import { ApiError } from "../error.js";
+import { BaseEntity } from "./BaseEntity.js";
+
+import type { AddCommentsData, DeleteCommentsData, UpdateCommentsData } from "./EndpointApi.types.js";
+import type { CommentItemNormalized } from "./serverDataType/Comment.js";
+
+export class Comment extends BaseEntity<CommentItemNormalized> {
+  static override entityType = "comments";
+
+  static override entityTag = "Comment";
+
+  static override SCHEMA_CONSTANTS: string[] = [
+    "ADD_COMMENTS"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_COMMENTS", "addComments"]
+  ] as const);
+
+  static UPDATE_BLOCKS = new Map([
+    ["ADD_COMMENTS", "updateComments"]
+  ] as const);
+
+  override defaultFields: Record<string, any> = {};
+
+  override removeFields: string[] = ["contextId", "contextType", "parentCommentId", "argval"];
+
+  /**
+   * Transforme les champs imbriqués (author) en instances d'entités.
+   * @param data - Les données brutes du serveur.
+   * @returns Les données transformées.
+   * @protected
+   */
+  protected override _transformServerData(data: CommentItemNormalized): CommentItemNormalized {
+    // Transformer author en instance User/Organization
+    if (data.author) {
+      data.author = this._linkNestedEntity(data.author);
+    }
+
+    // Transformer les replies récursivement si présentes
+    if (Array.isArray(data.replies)) {
+      data.replies = data.replies.map(reply => {
+        if (reply.author) {
+          reply.author = this._linkNestedEntity(reply.author);
+        }
+        return reply;
+      });
+    }
+
+    return data;
+  }
+
+  override async get(): Promise<never> {
+    throw new ApiError(`get n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async save(): Promise<Record<string, any>> {
+    // Pour les commentaires, on ne peut pas refresh après save
+    // car il n'y a pas d'endpoint GET_COMMENT
+    const originalRefresh = this.refresh;
+    this.refresh = async () => this._serverData; // No-op
+
+    try {
+      return await super.save();
+    } finally {
+      this.refresh = originalRefresh;
+    }
+  }
+
+  override _add = async (payload: Record<string, any>): Promise<void> => {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _add, utilisez save");
+    }
+
+    if(!this.parent?.id){
+      throw new Error("Le parent doit être défini pour ajouter un commentaire.");
+    }
+
+    if(payload.text === ""){
+      payload.text = " ";
+    }
+
+    // Si le parent est un Comment, on met son ID dans parentCommentId
+    if(this.parent.getEntityType() === "comments"){
+      payload.parentCommentId = this.parent.id;
+      // Le contextId et contextType doivent pointer vers l'entité racine (news, etc.)
+      // Il faut remonter jusqu'à trouver le parent qui n'est pas un commentaire
+      let rootParent = this.parent.parent;
+      while(rootParent && rootParent.getEntityType && rootParent.getEntityType() === "comments"){
+        rootParent = rootParent.parent;
+      }
+      if(rootParent){
+        payload.contextId = rootParent.id;
+        payload.contextType = rootParent.getEntityType();
+      } else {
+        throw new Error("Impossible de trouver l'entité racine pour le commentaire.");
+      }
+    } else {
+      // bug doit mettre une chaîne vide si pas de parentCommentId car dans getComments il y a un bug sur l'api dans la requete
+      payload.parentCommentId = payload.parentCommentId || "";
+      payload.contextId = this.parent.id;
+      payload.contextType = this.parent.getEntityType();
+    }
+    
+    
+    for (const [constant, methodName] of Array.from(Comment.ADD_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {},
+        []
+      );
+
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this._invokeBlockMethod(Comment.ADD_BLOCKS, methodName, blockData);
+        // L'API retourne l'ID soit dans data.object.id, soit dans data.id
+        const responseId = data?.object?.id || data?.id?.$id || data?.id;
+        if (!this.id && responseId) {
+          this._draftData.id = responseId;
+          this._setData(data.newComment as any, { forceInitialDraftReset: true });
+        }
+      }
+    }
+  };
+
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _update, utilisez save");
+    }
+
+    if(!this.parent?.id){
+      throw new Error("Le parent doit être défini pour ajouter un commentaire.");
+    }
+
+    // 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 = " ";
+    }
+
+    payload.params = {
+      text: payload.text
+    };
+
+    delete payload.text;
+
+    let hasChanged = false;
+    const data = await this.callIsConnected(() => this.endpointApi.updateComments(payload as UpdateCommentsData)) as any;
+    if(data?.comment){
+      this._setData(data.comment as any, { forceInitialDraftReset: true });
+    }
+    hasChanged = true;
+    return hasChanged;
+  };
+
+  async addComments(data: Partial<AddCommentsData> = {}): Promise<unknown> {
+    return this.callIsConnected(() => this.endpointApi.addComments(data as AddCommentsData));
+  }
+
+  async updateComments(data: Partial<UpdateCommentsData> = {}): Promise<unknown> {
+    return this.callIsConnected(() => this.endpointApi.updateComments(data as UpdateCommentsData));
+  }
+
+  /**
+   * Supprimer un commentaire : Supprime un commentaire existant.
+   * Constant : DELETE_COMMENT
+   */
+  async delete(): Promise<void> {
+    if(!this.id) {
+      throw new ApiError("Vous devez fournir un id pour supprimer un commentaire.", 400);
+    }
+    const data = {
+      pathParams: { id: this.id },
+    };
+    await this.callIsConnected(() => this.endpointApi.deleteComments(data as DeleteCommentsData));
+
+    // 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 réponse à ce commentaire (commentaire sur commentaire).
+   * @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;
+  }
+
+}