@communecter/cocolight-api-client 1.0.51 → 1.0.55

package/src/api/Event.ts

@@ -0,0 +1,332 @@
+import { ApiError } from "../error.js";
+import { BaseEntity, PaginatorPage } from "./BaseEntity.js";
+import { transformEntityRefs } from "../types/transforms.js";
+
+import type { AddEventData, GetAttendeesAdminData, GetAttendeesNoAdminData } from "./EndpointApi.types.js";
+import type { User } from "./User.js";
+import type { EventTransforms } from "../types/transforms.js";
+
+type EventItemNormalized = import("./serverDataType/Event.js").EventItemNormalized;
+
+export class Event extends BaseEntity<EventItemNormalized> {
+  static override entityType = "events";
+  static override entityTag = "Event";
+
+  static override SCHEMA_CONSTANTS: string[] = [
+    "ADD_EVENT",
+    // "UPDATE_BLOCK_DESCRIPTION",
+    // "UPDATE_BLOCK_INFO",
+    // "UPDATE_BLOCK_SOCIAL",
+    // "UPDATE_BLOCK_LOCALITY",
+    "UPDATE_BLOCK_SLUG",
+    "PROFIL_IMAGE"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_EVENT", "addEvent"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ] as const);
+
+  static UPDATE_BLOCKS = new Map([
+    // ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
+    // ["UPDATE_BLOCK_SOCIAL", "updateSocial"],
+    // ["UPDATE_BLOCK_LOCALITY", "updateLocality"],
+    // ["UPDATE_BLOCK_INFO", "updateInfo"],
+    ["UPDATE_BLOCK_SLUG", "updateSlug"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ] as const);
+
+  override defaultFields: Record<string, any> = {
+    typeElement: this.getEntityType()
+  };
+
+  override removeFields: string[] = [
+    "typeElement"
+  ];
+
+  override transforms: EventTransforms = {
+    parent: transformEntityRefs,
+    organizer: transformEntityRefs
+  };
+
+  override _add = async (payload: Record<string, any>): Promise<void> => {
+    if (!this._calledFromSave) {
+      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 Array.from(Event.ADD_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this._invokeBlockMethod(Event.ADD_BLOCKS, methodName, blockData);
+        if (!this.id && data?.map?.id) {
+          this._draftData.id = data.map.id;
+          this._draftData.slug = data.map.slug;
+        }
+      }
+    }
+  };
+
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour modifier cet événement", 403);
+    }
+
+    if (!this._calledFromSave) {
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
+    }
+
+    let hasChanged = false;
+
+    const blockData = this._extractAllValidFieldsFromSchema(
+      this.apiClient,
+      "ADD_EVENT",
+      { ...payload, ...this.defaultFields },
+      () => this.initialDraftData,
+      this.removeFields
+    );
+    if (blockData && Object.keys(blockData).length > 0) {
+      await this["addEvent"](blockData);
+      hasChanged = true;
+    }
+
+    if (payload.id) delete payload.id;
+
+    for (const [constant, methodName] of Array.from(Event.UPDATE_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => this.initialDraftData,
+        this.removeFields
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        await this._invokeBlockMethod(Event.UPDATE_BLOCKS, methodName, blockData);
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged;
+  };
+
+  async addEvent(data: Partial<AddEventData> = {}): Promise<unknown> {
+
+    if (!this.isMe && !data.organizer && this.parent) {
+      (data as any).organizer = {};
+      (data as any).organizer[`${this.parent.id}`] = {
+        type: this.parent.getEntityType(),
+        name: (this.parent as any).name
+      };
+    }
+
+    return this.callIsConnected(() => this.endpointApi.addEvent(data as AddEventData));
+  }
+
+
+  override async getOrganizations(): Promise<never> {
+    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getProjects(): Promise<never> {
+    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  async getEvents(): Promise<never> {
+    throw new ApiError(`getEvents - les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getPois(): Promise<never> {
+    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getBadgesIssuer(): Promise<never> {
+    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#getNews}
+   *
+   * Récupère les actualités de l'événement.
+   */
+  override async getNews(data: Parameters<BaseEntity<EventItemNormalized>["getNews"]>[0] = {}) {
+    return super.getNews(data);
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#getSubscribers}
+   *
+   * Récupère les abonnés de l'événement.
+   */
+  override async getSubscribers(data: Parameters<BaseEntity<EventItemNormalized>["getSubscribers"]>[0] = {}) {
+    return super.getSubscribers(data);
+  }
+
+  /**
+   * Récupérer les participants d'un événement.
+   * Constant : GET_ATTENDEES_NO_ADMIN
+   * @param data - Paramètres (partiels) de recherche/pagination.
+   * @param options - Options supplémentaires.
+   * @param options.toBeValidated - Indique si les participants doivent être validés.
+   * @param options.isAdmin - Indique si l'utilisateur est admin.
+   * @param options.isInviting - Indique si l'utilisateur est en attente d'invitation.
+   * @param options.roles - Liste des rôles à filtrer.
+   * @param isNext - Indique si c'est une recherche suivante (pagination).
+   * @returns - Un objet contenant le nombre de participants et la liste des participants.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération des participants.
+   *
+   * @example
+   * // Récupérer tous les participants
+   * const participants = await project.getAttendees();
+   *
+   * // Récupérer les participants avec validation en attente
+   * const participantsToBeValidated = await project.getAttendees({}, { toBeValidated: true });
+   *
+   * // Récupérer les participants avec un rôle spécifique
+   * const contributorsWithRole = await project.getAttendees({}, { roles: ["admin"] });
+   *
+   * // Récupérer les participants administrateurs
+   * const adminParticipants = await project.getAttendees({}, { isAdmin: true });
+   *
+   * // Récupérer les participants en attente d'invitation
+   * const invitingParticipants = await project.getAttendees({}, { isInviting: true });
+   *
+   */
+  async getAttendees(
+    data: Partial<GetAttendeesNoAdminData | GetAttendeesAdminData> = {},
+    options: {
+      toBeValidated?: boolean;
+      isAdmin?: boolean;
+      isAdminPending?: boolean;
+      isInviting?: boolean;
+      roles?: any[];
+    } = {}
+  ): Promise<PaginatorPage<User>> {
+    data.searchType = this._getDefaultFromEndpoint("GET_ATTENDEES_NO_ADMIN", "searchType") as GetAttendeesNoAdminData["searchType"];
+    // data.searchBy = "ALL";
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: async (finalData) => {
+
+        const { toBeValidated, isAdmin, isInviting, isAdminPending, roles = [] } = options;
+
+        if(this.isMe){
+          finalData.pathParams = { type: this.getEntityType(), id: this.id };
+          // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
+          // finalData.filters = {
+          //   [`links.events.${this.id}`]: { "$exists": true },
+          //   [`links.events.${this.id}.toBeValidated`]: { "$exists": false },
+          //   [`links.events.${this.id}.isInviting`]: { "$exists": false }
+          // };
+          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated, isAdmin, isAdminPending, isInviting, roles });
+        } else {
+          delete finalData?.pathParams;
+          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated: false, isAdmin, isInviting, roles });
+        }
+  
+        const fetchFn = this.isMe
+          ? () => this.callIsMe(() => this.endpointApi.getAttendeesAdmin(finalData))
+          : () => this.endpointApi.getAttendeesNoAdmin(finalData);
+
+        return fetchFn();
+      }
+    });
+
+    return paginator.next() as Promise<PaginatorPage<User>>;
+  }
+
+  override async project(): Promise<never> {
+    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async poi(): Promise<never> {
+    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async event(): Promise<never> {
+    throw new ApiError(`les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
+  }
+
+
+  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.
+   */
+  override async news(newsData: Parameters<BaseEntity<EventItemNormalized>["news"]>[0] = {}) {
+    return super.news(newsData);
+  }
+
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ event
+   *  (participation, abonnement)
+   * ───────────────────────────────
+   */
+
+  /**
+   * {@inheritDoc BaseEntity#requestToJoin}
+   *
+   * Rejoindre l'événement en tant que participant.
+   */
+  override async requestToJoin() {
+    return super.requestToJoin();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#acceptInvitation}
+   *
+   * Accepte une invitation à rejoindre l'événement.
+   * Cette action valide un lien en attente avec l'option `isInviting`.
+   */
+  override async acceptInvitation() {
+    return super.acceptInvitation();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#leave}
+   *
+   * Quitte l'événement, que ce soit en tant que participant ou administrateur.
+   * Cette action supprime le lien entre l'utilisateur et l'événement.
+   */
+  override async leave() {
+    return super.leave();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#follow}
+   *
+   * Suivre un événement.
+   * Cette action permet à l'utilisateur de suivre un événement.
+   */
+  override async follow() {
+    return super.follow();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#unfollow}
+   *
+   * Se désabonne d'un événement.
+   */
+  override async unfollow() {
+    return super.unfollow();
+  }
+  
+}

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);
+  }
+
+}