@communecter/cocolight-api-client 1.0.22 → 1.0.24

package/src/api/BaseEntity.js

@@ -4,8 +4,13 @@ import ObjectID from "bson-objectid";
 import pkg from "file-type";
 
 import { ApiAuthenticationError, ApiError, ApiResponseError, ApiValidationError } from "../error.js";
+import { autoSyncDraftFromSchema, reactive } from "../utils/reactive.js";
 const { fromBuffer } = pkg;
 
+/**
+ * @typedef {import("../ApiClient.js").default} ApiClient
+ * @typedef {import("./EndpointApi.js").default} EndpointApi
+ */
 
 /**
  * Classe de base pour toutes les entités métiers : utilisateurs, projets, organisations, etc.
@@ -26,6 +31,9 @@ export class BaseEntity {
   /** @type {boolean} Indique si `save()` est en cours */
   _calledFromSave = false;
 
+  /** @type {boolean} Indique si le draft est synchronisé avec le serveur */
+  _syncReactiveDraft = false;
+
   /**
    * Constructeur de l'entité.
    * @param {Object} parent - L'ApiClient ou une entité parente.
@@ -50,23 +58,29 @@ export class BaseEntity {
     this.deps = deps;
 
     if (parent?.__entityTag === "ApiClient") {
-      /** @type {import("../ApiClient.js").default} */
+      /** @type {ApiClient} */
       this.apiClient = parent;
       this.parent = null;
+      this.userContext = null;
     } else if (parent?.apiClient) {
-      /** @type {import("../ApiClient.js").default} */
+      /** @type {ApiClient} */
       this.apiClient = parent.apiClient;
       this.parent = parent;
+      if (parent?.__entityTag === "User") {
+        this.userContext = parent;
+      } else if (parent?.userContext) {
+        this.userContext = parent.userContext;
+      }
     } else {
       throw new ApiError("Parent invalide ou ApiClient manquant.");
     }
 
     // Gérer les deux cas : fonction constructeur ou instance
     if (typeof deps.EndpointApi === "function") {
-      /** @type {import("./EndpointApi.js").default} */
+      /** @type {EndpointApi} */
       this.endpointApi = new deps.EndpointApi(this.apiClient);
     } else if (typeof deps.EndpointApi === "object") {
-      /** @type {import("./EndpointApi.js").default} */
+      /** @type {EndpointApi} */
       this.endpointApi = deps.EndpointApi;
     } else {
       throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
@@ -93,6 +107,11 @@ export class BaseEntity {
     return this._draftData.id || null;
   }
 
+  /** @returns {string|null} Slug de l'entité */
+  get slug() {
+    return this._draftData.slug || null;
+  }
+
   /** Définit un ID (utilisé en interne) */
   _id(newId) {
     this._draftData.id = newId;
@@ -125,7 +144,7 @@ export class BaseEntity {
 
   /** @returns {boolean} Indique si cette entité représente l'utilisateur connecté */
   get isMe() {
-    return this.isConnected && this.userId === this.parent?.id;
+    return this.isConnected && this.userId === this.userContext?.id;
   }
 
   /** @returns {string} Type de l'entité (ex: 'citoyens') */
@@ -162,6 +181,10 @@ export class BaseEntity {
 
       if (!this.id && typeof this._add === "function") {
         await this._add(payload);
+        // on refresh le contexte utilisateur si besoin
+        if(this.userContext) {
+          await this.userContext.refresh();
+        }
         return await this.refresh();
       } else if (typeof this._update === "function") {
         const hasChanged = await this._update(payload);
@@ -184,19 +207,7 @@ export class BaseEntity {
    */
   static fromServerData(data, parent, deps) {
     const instance = new this(parent, {}, deps);
-    instance._serverData = { ...data };
-
-    const { draft, proxy } = instance._buildDraftAndProxy({
-      data: { ...data, ...instance.defaultFields },
-      serverData: instance._serverData,
-      constant: this.SCHEMA_CONSTANTS,
-      apiClient: instance.apiClient,
-      transforms: instance.transforms,
-      removeFields: instance.removeFields
-    });
-
-    instance._draftData = draft;
-    instance.data = proxy;
+    instance._setData(data);
     return instance;
   }
 
@@ -208,7 +219,10 @@ export class BaseEntity {
    * @private
    */
   _setData(newData) {
-    this._serverData = { ...newData };
+    if (this.userContext && this.userContext !== this) {
+      this.apiClient._logger?.info?.(`[${this.__entityTag}] Mise à jour liée à userContext : ${this.userContext.id}`);
+    }
+    this._serverData = reactive({ ...newData });
 
     const { draft, proxy } = this._buildDraftAndProxy({
       data: { ...newData, ...this.defaultFields },
@@ -221,6 +235,10 @@ export class BaseEntity {
     this._initialDraftData = JSON.parse(JSON.stringify(draft));
     this._draftData = draft;
     this.data = proxy;
+
+    if (this._syncReactiveDraft) {
+      this.setupReactiveSync();
+    }
   }
 
 
@@ -831,6 +849,25 @@ export class BaseEntity {
     return Object.keys(changed).length > 0 ? changed : null;
   }
 
+  /**
+   * ───────────────────────────────
+   * ReactiveMixin
+   * ───────────────────────────────
+   */
+
+  /**
+   * Active la synchronisation réactive entre le brouillon et le schéma.
+   * 
+   * @returns {void}
+   * @public
+   */
+  setupReactiveSync() {
+    if (!this._syncReactiveDraft) {
+      this._syncReactiveDraft = true;
+    }
+    autoSyncDraftFromSchema(this);
+  }
+
   /**
    * ───────────────────────────────
    * MutualEntityMixin
@@ -1101,8 +1138,8 @@ export class BaseEntity {
 
       const fetchKeysByEntity = {
         citoyens: ["id", "slug"],
-        organisations: ["id", "slug"],
-        projets: ["id", "slug"],
+        organizations: ["id", "slug"],
+        projects: ["id", "slug"],
         events: ["id", "slug"],
         poi: ["id", "slug"],
         news: ["id"],
@@ -1122,6 +1159,307 @@ export class BaseEntity {
     }
   }
 
+  /**
+   * Construit dynamiquement des filtres sur un lien entre entités
+   *
+   * @param {string} id - L'ID de l'entité cible.
+   * @param {Object} options - Options de filtrage.
+   * @param {"memberOf" | "projects"} [options.linkType] - Le type de lien (ex: "memberOf", "projects", etc.).
+   * @param {boolean} [options.isAdmin] - Si défini, filtre selon l'existence de isAdmin.
+   * @param {boolean} [options.isAdminPending] - Si défini, filtre selon l'existence de isAdminPending.
+   * @param {boolean} [options.isInviting] - Si défini, filtre selon l'existence de isInviting.
+   * @param {boolean} [options.toBeValidated] - Si défini, filtre selon l'existence de toBeValidated.
+   * @param {Array<string>} [options.roles] - Rôles à filtrer.
+   * @returns {Object} - Un objet de filtres à passer à une requête.
+   * @throws {TypeError} - Si les types des paramètres ne sont pas valides.
+   * @private
+   */
+  _buildLinkFilters(id, {
+    linkType,
+    isAdmin,
+    isAdminPending,
+    isInviting,
+    toBeValidated = false,
+    roles = []
+  } = {}) {
+    if (typeof id !== "string") throw new TypeError("id doit être une chaîne.");
+    if (typeof linkType !== "string") throw new TypeError("linkType doit être une chaîne.");
+    if (typeof isAdmin !== "undefined" && typeof isAdmin !== "boolean") {
+      throw new TypeError("isAdmin doit être un booléen.");
+    }
+    if (typeof isAdminPending !== "undefined" && typeof isAdminPending !== "boolean") {
+      throw new TypeError("isAdminPending doit être un booléen.");
+    }
+    if (typeof isInviting !== "undefined" && typeof isInviting !== "boolean") {
+      throw new TypeError("isInviting doit être un booléen.");
+    }
+    if (typeof toBeValidated !== "undefined" && typeof toBeValidated !== "boolean") {
+      throw new TypeError("toBeValidated doit être un booléen.");
+    }
+    if (!Array.isArray(roles)) {
+      throw new TypeError("roles doit être un tableau de chaînes.");
+    }
+
+    const path = `links.${linkType}.${id}`;
+    const filters = {
+      [`${path}`]: { $exists: true }
+    };
+
+    if (typeof toBeValidated === "boolean") {
+      filters[`${path}.toBeValidated`] = { $exists: toBeValidated };
+    }
+
+    if (typeof isInviting === "boolean") {
+      filters[`${path}.isInviting`] = { $exists: isInviting };
+    }
+
+    if (isAdmin === true) {
+      filters[`${path}.isAdmin`] = { $exists: true };
+    }
+
+    if(isAdminPending === true) {
+      filters[`${path}.isAdminPending`] = { $exists: true };
+    }
+
+    if (roles.length > 0) {
+      filters[`${path}.roles`] = { $in: roles };
+    }
+
+    return filters;
+  }
+
+  /**
+   * Retourne les métadonnées de lien pour une entité :
+   * - `linkType` : clé dans `serverData.links`
+   * - `connectTypeConnect` : valeur envoyée pour `connect()`
+   * - `connectTypeDisconnect` : valeur envoyée pour `disconnect()`
+   * @typedef {Object} LinkMeta
+   * @property {string} linkType
+   * @property {string} connectTypeConnect
+   * @property {string} connectTypeDisconnect
+   * @returns {LinkMeta}
+   * @throws {ApiError} - Si le type d'entité est inconnu.
+   * @private
+   */
+  _getLinkMeta() {
+    const map = {
+      organizations: {
+        linkType: "memberOf",
+        connectTypeConnect: "member",
+        connectTypeDisconnect: "members"
+      },
+      projects: {
+        linkType: "projects",
+        connectTypeConnect: "contributor",
+        connectTypeDisconnect: "contributors"
+      },
+      events: {
+        linkType: "events",
+        connectTypeConnect: "attendee",
+        connectTypeDisconnect: "attendees"
+      },
+      citoyens: {
+        linkType: "friends",
+        connectTypeConnect: "friend",
+        connectTypeDisconnect: "friends"
+      }
+    };
+
+    const entityType = this.getEntityType();
+    const meta = map[entityType];
+
+    if (!meta) {
+      throw new ApiError(`Aucune correspondance de lien définie pour le type d'entité "${entityType}"`);
+    }
+
+    return meta;
+  }
+
+  /**
+   * Vérifie si l'entité prend en charge les opérations de lien (`connect`, `disconnect`, etc.).
+   * Utilise `_getLinkMeta()` comme source unique de vérité.
+   *
+   * @throws {ApiError} - Si l'entité ne supporte pas les liens.
+   * @private
+   */
+  _checkLinkableEntity() {
+    try {
+      this._getLinkMeta(); // si l'entité n'est pas supportée, ça throw déjà
+    } catch (error) {
+      if (error instanceof ApiError) {
+        throw new ApiError(`L'entité "${this.getEntityType()}" ne prend pas en charge les actions de lien.`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Retourne le lien de l'utilisateur connecté avec l'entité cible (dans `parent.serverData.links`)
+   * @private
+   */
+  _getLinkFromConnectedUser() {
+    const { linkType } = this._getLinkMeta();
+    return this?.userContext?.serverData?.links?.[linkType]?.[this.id] || null;
+  }
+
+  /**
+   * Soumet une demande de connexion à une entité (ex : membre, contributeur),
+   * ou valide l'invitation si elle existe déjà.
+   *
+   * @returns {Promise<Object>} - Résultat de l'API
+   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
+   * @private
+   */
+  async _submitLinkRequest() {
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const { connectTypeConnect } = this._getLinkMeta();
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    // Cas : aucun lien → on demande à se connecter
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: connectTypeConnect
+      };
+
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      const retour = await this.callIsMe(() => this.endpointApi.connect(data));
+      await this.userContext.refresh();
+      return retour;
+    }
+
+    // Cas : invitation reçue → on valide l'invitation
+    if (userLink.isInviting) {
+      return this._acceptLinkRequest();
+    }
+
+    // Cas : déjà en attente
+    if (userLink.toBeValidated) {
+      throw new ApiError("Vous êtes déjà en attente de validation.");
+    }
+
+    // Cas par défaut : rien à faire
+    throw new ApiError("Vous êtes déjà connecté à cette entité.");
+  }
+
+  /**
+   * Soumet une demande pour devenir administrateur d'une entité.
+   *
+   * @returns {Promise<Object>}
+   * @throws {ApiError}
+   * @private
+   */
+  async _submitLinkRequestAdmin() {
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    // Aucun lien existant → envoie une demande avec rôle "admin"
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: "admin"
+      };
+
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      const retour = await this.callIsMe(() => this.endpointApi.connect(data));
+      await this.userContext.refresh();
+      return retour;
+    }
+
+    // Invitation reçue → accepte automatiquement
+    if (userLink.isInviting) {
+      return this._acceptLinkRequest();
+    }
+
+    // Déjà en attente pour admin
+    if (userLink.toBeValidated && userLink.isAdminPending) {
+      throw new ApiError("Vous êtes déjà en attente de validation pour devenir admin.");
+    }
+
+    // Déjà en attente pour un autre rôle
+    if (userLink.toBeValidated) {
+      throw new ApiError("Vous êtes déjà en attente de validation pour rejoindre cette entité.");
+    }
+
+    // Déjà connecté
+    throw new ApiError("Vous êtes déjà connecté à cette entité.");
+  }
+
+  /**
+   * Accepte une demande de lien (ex : invitation à rejoindre un groupe).
+   * 
+   * @returns {Promise<Object>} - Résultat de l'API
+   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
+   * @private
+   */
+  async _acceptLinkRequest() {
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (userLink.isInviting) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        linkOption: "isInviting"
+      };
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      const retour = await this.callIsMe(() => this.endpointApi.linkValidate(data));
+      await this.userContext.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'avez pas d'invitation à valider.");
+  }
+
+  /**
+   * Annule une demande de lien ou se déconnecte d'une entité.
+   * 
+   * @returns {Promise<Object>} - Résultat de l'API
+   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
+   * @private
+   */
+  async _leaveLinkRequest() {
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const { connectTypeDisconnect } = this._getLinkMeta();
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (!userLink) {
+      throw new ApiError("Vous n'êtes pas connecté à cette entité.");
+    }
+
+    const data = {
+      parentType: this.getEntityType(),
+      parentId: this.id,
+      // Normalement en auto dans le schema mais je le met quand même
+      connectType: connectTypeDisconnect
+    };
+    
+    // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+    const retour = await this.callIsMe(() => this.endpointApi.disconnect(data));
+    await this.userContext.refresh();
+    return retour;
+  }
+
   /**
    * ───────────────────────────────
    * EntityMixin
@@ -1543,6 +1881,289 @@ export class BaseEntity {
     return this._createFilteredProxy(rawList);
   }
 
+  /**
+   * Soumet une demande pour rejoindre l'entité courante (ex. organisation, projet, événement...).
+   * Si une invitation est en attente, elle est automatiquement acceptée.
+   *
+   * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
+   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
+   */
+  async requestToJoin(){
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
+    }
+    this._checkLinkableEntity();
+    return this._submitLinkRequest();
+  }
+
+  /**
+   * Soumet une demande pour devenir administrateur de l'entité courante.
+   * Si une invitation est en attente, elle est automatiquement validée.
+   *
+   * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
+   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
+   */
+  async requestToJoinAdmin(){
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
+    }
+    this._checkLinkableEntity();
+    return this._submitLinkRequestAdmin();
+  }
+
+  /**
+   * Accepte une invitation à rejoindre l'entité courante.
+   * Ne fonctionne que si un lien avec `isInviting` est détecté.
+   *
+   * @returns {Promise<Object>} - Résultat de l'acceptation de l'invitation.
+   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'entité ne supporte pas cette action.
+   */
+  async acceptInvitation(){
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
+    }
+    this._checkLinkableEntity();
+    return this._acceptLinkRequest();
+  }
+
+  /**
+   * Se désengage de l'entité courante : quitte un rôle (membre, contributeur, etc.).
+   *
+   * @returns {Promise<Object>} - Résultat de la déconnexion.
+   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si l'utilisateur n'est pas lié à cette entité.
+   */
+  async leave() {
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
+    }
+    this._checkLinkableEntity();
+    return this._leaveLinkRequest();
+  }
+
+  /**
+   * S'abonne à l'entité courante.
+   * 
+   * @returns {Promise<Object>} - Résultat de l'abonnement.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
+   */
+  async follow() {
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour suivre cette entité.");
+    }
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id
+      };
+      const retour = await this.callIsMe(() => this.endpointApi.follow(data));
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.userContext.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous êtes déjà abonné à cette entité.");
+  }
+
+  /**
+   * Se désabonne de l'entité courante.
+   * 
+   * @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() {
+    if (!this.isMe) {
+      throw new ApiError("Vous devez être connecté pour vous désabonner.");
+    }
+
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: "followers"
+      };
+      const retour = await this.callIsMe(() => this.endpointApi.disconnect(data));
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.userContext.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'êtes pas abonné à cette entité.");
+  }
+  
+
+  /**
+   * Vérifie si l'utilisateur est connecté et a accès à l'entité.
+   * 
+   * @param {string} action - Action à effectuer.
+   * @returns {void}
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
+   * @private
+   */
+  _checkAccess(action = "effectuer cette action") {
+    if (!this.isMe) {
+      throw new ApiError(`Vous devez être connecté pour ${action}`);
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+  }
+
+  /**
+   * Vérifie si l'utilisateur a un lien valide avec l'entité.
+   * 
+   * @param {Object} userLink - Lien de l'utilisateur avec l'entité.
+   * @param {boolean} userLink.toBeValidated - Indique si le lien est en attente de validation.
+   * @param {boolean} userLink.isInviting - Indique si l'utilisateur a été invité.
+   * @returns {boolean} - `true` si le lien est valide, `false` sinon.
+   * @private
+   */
+  _validateUserLink(userLink) {
+    if (!userLink) return false;
+    const { toBeValidated, isInviting } = userLink;
+    return !toBeValidated && !isInviting;
+  }
+
+  /**
+   * Vérifie si l'entité est d'un type spécifique.
+   * 
+   * @param {...string} types - Types d'entité attendus.
+   * @throws {ApiError} - Si l'entité n'est pas du type attendu.
+   * @private
+   */
+  _assertEntityType(...types) {
+    const expectedTypes = Array.isArray(types[0]) ? types[0] : types;
+    if (!expectedTypes.includes(this.getEntityType())) {
+      throw new ApiError(`L'entité doit être de type : ${expectedTypes.join(", ")}, reçu : ${this.getEntityType()}`);
+    }
+  }
+
+  /**
+   * Vérifie si l'entité est liée à un type de lien spécifique.
+   * 
+   * @param {string} linkType - Type de lien à vérifier.
+   * @returns {boolean} - `true` si l'entité est liée, `false` sinon.
+   * @private
+   */
+  _isLinked(linkType) {
+    return !!this.userContext?.serverData?.links?.[linkType]?.[this.id];
+  }
+
+  /**
+   * Vérifie si l'utilisateur est l'auteur de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est l'auteur, `false` sinon.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si les données du serveur ne sont pas disponibles.
+   */
+  isAuthor() {
+    this._checkAccess("vérifier l'auteur");
+    if (!this.serverData) {
+      throw new ApiError("Aucune donnée serveur disponible.");
+    }
+    return this.userId && this.serverData?.creator === this.userId;
+  }
+
+  /**
+   * Vérifie si l'utilisateur est administrateur de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est administrateur, `false` sinon.
+   * @throws {ApiError}
+   */
+  isAdmin() {
+    this._checkAccess("vérifier l'administrateur.");
+    this._assertEntityType("organizations", "projects", "events");
+    const userLink = this._getLinkFromConnectedUser();
+    return this._validateUserLink(userLink) && userLink?.isAdmin === true && !userLink?.isAdminPending;
+  }
+
+  /**
+   * Vérifie si l'utilisateur est soit l'auteur, soit administrateur de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
+   * @throws {ApiError}
+   */
+  isAuthorOrAdmin() {
+    this._checkAccess("vérifier l'auteur ou l'administrateur.");
+    return this.isAuthor() || this.isAdmin();
+  }
+
+  /**
+   * Vérifie si l'utilisateur est membre de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est membre, `false` sinon.
+   * @throws {ApiError}
+   */
+  isMember() {
+    this._checkAccess("vérifier le membre.");
+    this._assertEntityType("organizations");
+    const userLink = this._getLinkFromConnectedUser();
+    return this._validateUserLink(userLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur est contributeur de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est contributeur, `false` sinon.
+   * @throws {ApiError}
+   */
+  isContributor() {
+    this._checkAccess("vérifier le contributeur.");
+    this._assertEntityType("projects");
+    const userLink = this._getLinkFromConnectedUser();
+    return this._validateUserLink(userLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur est participant de l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est participant, `false` sinon.
+   * @throws {ApiError}
+   */
+  isAttendee() {
+    this._checkAccess("vérifier si vous êtes un participant.");
+    this._assertEntityType("events");
+    const userLink = this._getLinkFromConnectedUser();
+    return this._validateUserLink(userLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur suit l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur suit l'entité, `false` sinon.
+   * @throws {ApiError}
+   */
+  isFollower() {
+    this._checkAccess("vérifier si il vous suit.");
+    this._assertEntityType("citoyens","organizations", "projects", "events", "poi");
+    return this._isLinked("followers");
+  }
+
+  /**
+   * Vérifie si l'utilisateur est abonné à l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est abonné, `false` sinon.
+   * @throws {ApiError}
+   */
+  isFollowing() {
+    this._checkAccess("vérifier si vous le suivez.");
+    this._assertEntityType("citoyens","organizations", "projects", "events", "poi");
+    return this._isLinked("follows");
+  }
+
+
+
 }
 
 export default BaseEntity;