@communecter/cocolight-api-client 1.0.18 → 1.0.20

package/src/api/User.js

@@ -1,14 +1,9 @@
 import { ApiError, ApiResponseError } from "../error.js";
-import { DraftStateMixin } from "../mixin/DraftStateMixin.js";
-import { MutualEntityMixin } from "../mixin/MutualEntityMixin.js";
+import BaseEntity from "./BaseEntity.js";
 import { UserMixin } from "../mixin/UserMixin.js";
-import { UtilMixin } from "../mixin/UtilMixin.js";
 
 // User.js
-export class User {
-  #draftData = {};
-  #initialDraftData = {};
-  #serverData = null;
+export class User extends BaseEntity {
 
   static entityType = "citoyens";
 
@@ -30,6 +25,41 @@ export class User {
     ["PROFIL_IMAGE", "updateImageProfil"]
   ]);
 
+  /**
+   * Champs par défaut pour les schemas json ou l'on extrait les fields. (pour les if/else/then)
+   * 
+   * @property {Object} defaultFields - Un objet contenant les propriétés par défaut pour l'entité User.
+   */
+  defaultFields = {
+    typeElement: this.getEntityType(), 
+  };
+    
+  /**
+       * Champs à supprimer de draft lors de la construction du proxy.
+       * 
+       * @property {Array<string>} removeFields - Un tableau de chaînes représentant les champs à supprimer.
+       */
+  removeFields = [
+    "typeElement",
+  ];
+      
+  /**
+       * Transformateurs appliqués lors de la lecture du draft.
+       *
+       * @type {Object<string, function>}
+       */
+  transforms = {
+    github: (val, full) => full?.socialNetwork?.github,
+    gitlab: (val, full) => full?.socialNetwork?.gitlab,
+    facebook: (val, full) => full?.socialNetwork?.facebook,
+    twitter: (val, full) => full?.socialNetwork?.twitter,
+    instagram: (val, full) => full?.socialNetwork?.instagram,
+    diaspora: (val, full) => full?.socialNetwork?.diaspora,
+    mastodon: (val, full) => full?.socialNetwork?.mastodon,
+    telegram: (val, full) => full?.socialNetwork?.telegram,
+    signal: (val, full) => full?.socialNetwork?.signal
+  };
+      
   /**
    * Crée une instance de User.
    *
@@ -41,115 +71,42 @@ export class User {
    * @param {function|object} deps.EndpointApi - Classe ou instance de EndpointApi.
    * @param {function} deps.Organization - Classe Organization.
    * @param {function} deps.Project - Classe Project.
+   * @param {function} deps.Event - Classe Events.
+   * @param {function} deps.Poi - Classe Poi.
+   * @param {function} deps.Badge - Classe Badge.
    * @param {function} deps.News - Classe News.
    *
    * @throws {ApiError} - Si des dépendances nécessaires sont manquantes ou invalides.
    */
 
-  constructor(apiClient, data = {}, deps = {}) {
-    this.__entityTag = "User";
-
+  constructor(parent, data = {}, deps = {}) {
     if(!deps.EndpointApi){
       throw new ApiError("EndpointApi class must be injected to avoid circular dependency.");
     }
     if (!data?.id && !data?.slug) {
       throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.");
     }
-
+  
     if (!deps.Organization) throw new ApiError("Organization class must be injected.");
     if (!deps.Project) throw new ApiError("Project class must be injected.");
+    if (!deps.Event) throw new ApiError("Event class must be injected.");
+    if (!deps.Poi) throw new ApiError("Poi class must be injected.");
+    if (!deps.Badge) throw new ApiError("Badge class must be injected.");
     if (!deps.News) throw new ApiError("News class must be injected.");
+      
+    super(parent, data, deps);
 
-    this.apiClient = apiClient;
-
-    this.deps = deps;
-
-    // Gérer les deux cas : fonction constructeur ou instance
-    if (typeof deps.EndpointApi === "function") {
-      this.endpointApi = new deps.EndpointApi(this.apiClient);
-    } else if (typeof deps.EndpointApi === "object") {
-      this.endpointApi = deps.EndpointApi;
-    } else {
-      throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
-    }
-
-    this.#serverData = null;
-    
-    const { draft, proxy } = this._buildDraftAndProxy({
-      data: { ...data, ...this.defaultFields },
-      serverData: this.#serverData,
-      constant: User.SCHEMA_CONSTANTS,
-      apiClient: this.apiClient,
-      transforms: this.transforms,
-      removeFields: this.removeFields
-    });
-    
-    this.#initialDraftData = JSON.parse(JSON.stringify(draft)); // snapshot propre
-    this.#draftData = draft;
-    this.data = proxy;
-  }
-
-  get id() {
-    return this.#draftData.id || null;
-  }
-
-  _id(newId) {
-    this.#draftData.id = newId;
+    // this.__entityTag = "User";
   }
       
   get slug() {
-    return this.#draftData.slug || null;
-  }
-  
-  get isConnected() {
-    return this.apiClient.isConnected;
-  }
-
-  _setData(newData) {
-    this.#serverData = { ...newData };
-
-    const { draft, proxy } = this._buildDraftAndProxy({
-      data: { ...newData, ...this.defaultFields },
-      serverData: this.#serverData,
-      constant: User.SCHEMA_CONSTANTS,
-      apiClient: this.apiClient,
-      transforms: this.transforms,
-      removeFields: this.removeFields
-    });
-    this.#initialDraftData = JSON.parse(JSON.stringify(draft));
-    this.#draftData = draft;
-    this.data = proxy;
-  }
-
-  getEntityType() {
-    return User.entityType;
-  }
-
-  get userId() {
-    return this.apiClient.userId;
+    return this._draftData.slug || null;
   }
   
   get isMe() {
     return this.isConnected && this.userId === this.id;
   }
 
-  get draftData() {
-    return this.#draftData;
-  }
-
-  get initialDraftData() {
-    return this.#initialDraftData;
-  }
-  
-  get serverData() {
-    return this.#serverData;
-  }
-
-  async refresh() {
-    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
-    return this.get();
-  }
-
   /**
      * Récupère le profil complet de l'utilisateur.
      * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
@@ -195,22 +152,14 @@ export class User {
    * @throws {ApiError} - Si l'utilisateur n'est pas autorisé.
    */
   async save() {
-
     if(!this.isMe){
       throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.");
     }
+    await super.save();
+  }
 
-    const payload = { ...this.#draftData };
-  
-    if (this.id) {
-      const hasChanged = await this._update(payload);
-      if (hasChanged) {
-        // this._updateInitialDraftSnapshot();
-        await this.refresh();
-      }
-      return this.#serverData;
-    }
-  
+  async _add() {
+    throw new ApiError("Vous ne pouvez pas ajouter un utilisateur par ce moyen.");
   }
 
   /**
@@ -220,6 +169,10 @@ export class User {
    * @returns {Promise<boolean>} - Indique s'il y a eu une modification réelle.
    */
   async _update(payload){
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _update, utilisez save");
+    }
+
     if(payload.id){
       delete payload.id;
     }
@@ -244,6 +197,26 @@ export class User {
     return hasChanged;
   }
 
+  static fromServerData(data, parent, deps) {
+    const instance = new User(parent.apiClient, data, deps);
+    instance._serverData = { ...data };
+    // est ce que je besoin de ça si il est contruit dans le constructeur ?
+    // il doit y avaoir une raison pour les autres objets
+    const { draft, proxy } = instance._buildDraftAndProxy({
+      data: { ...data, ...instance.defaultFields },
+      serverData: instance._serverData,
+      constant: User.SCHEMA_CONSTANTS,
+      apiClient: instance.apiClient,
+      transforms: instance.transforms,
+      removeFields: instance.removeFields
+    });
+
+    instance._draftData = draft;
+    instance.data = proxy;
+
+    return instance;
+  }
+
   /**
    * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
    * Constant : UPDATE_SETTINGS
@@ -253,7 +226,10 @@ export class User {
    * @returns {Promise<void>} - Résultat de la mise à jour.
    */
   async updateSettings(data = {}) {
-    await this.callIsMe(() => this.endpointApi.updateSettings(data));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les paramètres.");
+    }
+    await super.updateSettings(data);
     await this.refresh();
   }
 
@@ -262,7 +238,10 @@ export class User {
    * Constant : UPDATE_BLOCK_DESCRIPTION
    */
   async updateDescription(data = {}) {
-    return this.callIsMe(() => this.endpointApi.updateBlockDescription(data));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la description.");
+    }
+    return super.updateDescription(data);
   }
   
   /**
@@ -270,7 +249,10 @@ export class User {
      * Constant : UPDATE_BLOCK_INFO
      */
   async updateInfo(data = {}) {
-    return this.callIsMe(() => this.endpointApi.updateBlockInfo(data));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les informations.");
+    }
+    return super.updateInfo(data);
   }
   
   /**
@@ -278,7 +260,10 @@ export class User {
      * Constant : UPDATE_BLOCK_SOCIAL
      */
   async updateSocial(data = {}) {
-    return this.callIsMe(() => this.endpointApi.updateBlockSocial(data));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les réseaux sociaux.");
+    }
+    return super.updateSocial(data);
   }
   
   /**
@@ -286,7 +271,10 @@ export class User {
      * Constant : UPDATE_BLOCK_LOCALITY
      */
   async updateLocality(data = {}) {
-    return this.callIsMe(() => this.endpointApi.updateBlockLocality(data));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la localité.");
+    }
+    return super.updateLocality(data);
   }
   
   /**
@@ -294,15 +282,10 @@ export class User {
      * Constant : UPDATE_BLOCK_SLUG
      */
   async updateSlug({ slug }) {
-    try {
-      await this.endpointApi.check({ slug });
-    } catch (error) {
-      if(error instanceof ApiResponseError) {
-        throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
-      }
-      throw error;
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour le slug.");
     }
-    return this.callIsMe(() => this.endpointApi.updateBlockSlug({ slug }));
+    return super.updateSlug({ slug });
   }
 
   /**
@@ -310,8 +293,10 @@ export class User {
    * Constant : PROFIL_IMAGE
    */
   async updateImageProfil({ profil_avatar: image  }) {
-    image = await this._validateImage(image);
-    return this.callIsMe(() => this.endpointApi.profilImage({ profil_avatar: image }));
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour l'image de profil.");
+    }
+    return super.updateImageProfil({ profil_avatar: image });
   }
   
   /**
@@ -346,14 +331,8 @@ export class User {
     const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
     arrayObjetOrganizations.count.total = totalCount;
   
-    // transformation des résultats
-    const rawOrganizationsList = arrayObjetOrganizations.results.map((orgData) =>
-      this.deps.Organization.fromServerData(orgData, this, {
-        User,
-        Project: this.deps.Project,
-        News: this.deps.News,
-        EndpointApi: this.deps.EndpointApi
-      })
+    const rawOrganizationsList = arrayObjetOrganizations.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
     );
   
     return {
@@ -361,110 +340,166 @@ export class User {
       results: rawOrganizationsList
     };
   }
-  
+
   /**
-   * Crée une instance d'organisation et récupère son profil si nécessaire.
-   *
-   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
+   * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
+   * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
    */
-  async organization(organizationData = {}, ) {
-    try {
-      const organization = new this.deps.Organization(this, organizationData, { User, Project: this.deps.Project, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
-      if (organizationData.id || organizationData.slug) {
-        await organization.get();
-      }
-      return organization;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.organization] Erreur lors de la création d'une instance organization :`, error.message);
-      throw error;
+  async getProjects(data = {}) {
+    return super.getProjects(data);
+  }
+
+  /**
+   * Récupérer les POIs
+   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
+   */
+  async getPois(data = {}) {
+    return super.getPois(data);
+  }
+
+  /**
+   * Récupérer les actualités : Récupère la liste des actualités liées à l'utilisateur.
+   * Constant : GET_NEWS
+   */
+  async getNews(data = {}) {
+    return super.getNews(data);
+  }
+
+  /**
+   * Récupérer les amis administrables : Récupère les amis administrée par l’utilisateur.
+   * Constant : GET_FRIENDS_ADMIN
+   * question : qui peut voir la liste d'amis, seulement l'utilisateur connecté ? ou tous les utilisateurs connectés ?
+   * actuellement, c'est tous les utilisateurs connectés
+   */
+  async getFriends(data = {}) {
+    delete data?.pathParams;
+
+    if (!this.isMe){
+      // is not me add id
+      data.pathParams = { id: this.id };
     }
+
+    const arrayObjetFriends = await this.endpointApi.getFriendsAdmin(data);
+    if(!Array.isArray(arrayObjetFriends.results)){
+      throw new ApiResponseError("Erreur lors de la récupération des amis administrables.", 500, arrayObjetFriends);
+
+    }
+
+    const rawFriendsList = arrayObjetFriends.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetFriends?.count?.citoyens ?? 0,
+      results: rawFriendsList
+    };
   }
 
   /**
-   * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
-   * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
+   * Récupérer les suivis
+   * Constant : GET_SUBSCRIPTIONS / GET_SUBSCRIPTIONS_ADMIN
    */
-  async getProjects(data = {}) {
+  async getSubscriptions(data = {}) {
     delete data?.pathParams;
   
     const fetchFn = this.isMe
-      ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(data))
-      : () => this.endpointApi.getProjectsNoAdmin(data);
+      ? () => this.callIsMe(() => this.endpointApi.getSubscriptionsAdmin(data))
+      : () => this.endpointApi.getSubscriptions(data);
   
     if (!this.isMe && !data.filters) {
       data.filters = {
-        "$or": {
-          [`links.contributors.${this.id}`]: { "$exists": true },
-          [`parent.${this.id}`]: { "$exists": true }
-        },
-        [`links.contributors.${this.id}`]: { "$exists": true }
-        // TODO : revoir les filtres pour harmoniser avec orga (schema pris de cocolight)
+        [`links.followers.${this.id}`]: { "$exists": true },
       };
     }
   
-    const arrayObjetProjects = await fetchFn();
-  
-    if (!Array.isArray(arrayObjetProjects.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjetProjects.results);
+    const arrayObjetSubscriptions = await fetchFn();
+    if (!Array.isArray(arrayObjetSubscriptions.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des abonnements.", 500, arrayObjetSubscriptions.results);
     }
-  
-    const rawProjectsList = arrayObjetProjects.results.map((projectData) =>
-      this.deps.Project.fromServerData(projectData, this, {
-        User,
-        News: this.deps.News,
-        EndpointApi: this.deps.EndpointApi
-      })
+
+    // lier les entités au objets
+    const rawSubscriptionsList = arrayObjetSubscriptions.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
     );
-  
+
     return {
-      count: arrayObjetProjects?.count?.projects ?? 0,
-      results: rawProjectsList
+      count: arrayObjetSubscriptions.count,
+      results: rawSubscriptionsList
     };
+  }   
+
+  /**
+   * Récupérer les abonnés
+   * Constant : GET_SUBSCRIBERS
+   */
+  async getSubscribers(data = {}) {
+    return super.getSubscribers(data);
   }
-  
+
   /**
-   * Crée une instance de projet et récupère son profil si nécessaire.
+   * Obtenir la liste des événements
+   * Constant : GET_EVENTS
+   * TODO : il n'est pas fait encore pour GET_EVENTS_ADMIN / GET_EVENTS_NO_ADMIN comme les autres dans endpointApi
+   */
+
+  /**
+   * Liste des badges créés par l'utilisateur
+   * Constant : GET_BADGES
+   */
+  async getBadgesIssuer(data = {}) {
+    return super.getBadgesIssuer(data);
+  }
+
+  /**
+   * Liste des badges associés à l'utilisateur
+   * 
+   * TODO : documenté le fonctionnement et sont utilisation avec un exemple
+   */
+  async getBadges(filter = {}) {
+    /*
+      "badges": {
+            "627df5663a0fae60e57f4a31": {
+                "attenteRecepteur": true,
+                "expiredOn": false,
+                "isParcours": "false",
+                "issuedOn": "2023-10-02T14:00:00.000Z",
+                "name": "CODEV",
+                "show": "true",
+            },
+        },
+    */
+
+    const filteredBadges = await this.linkEntitiesFromServerData("badges", filter);
+    // voir si je les met dans objet { count, results }
+    return filteredBadges;
+  }
+
+  /**
+   * Crée une instance d'organisation et récupère son profil si nécessaire.
    *
-   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
-   * @throws {Error} Si une erreur se produit lors de la création du projet.
+   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
+   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
    */
-  async project(projectData = {}, ) {
-    try {
-      const project = new this.deps.Project(this, projectData, { User, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
-      if (projectData.id || projectData.slug) {
-        await project.get();
-      }
-      return project;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.project] Erreur lors de la création d'une instance project :`, error.message);
-      throw error;
+  async organization(organizationData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
     }
+    return super.organization(organizationData);
   }
 
   /**
-   * Récupérer les actualités : Récupère la liste des actualités liées à l'utilisateur.
-   * Constant : GET_NEWS
+   * Crée une instance de projet et récupère son profil si nécessaire.
+   *
+   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
+   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
+   * @throws {Error} Si une erreur se produit lors de la création du projet.
    */
-  async getNews(data = {}) {
-    if (data.pathParams) {
-      delete data.pathParams;
-    }
-    if (!this.isMe){
-      // is not me add id
-      data.pathParams = { id: this.id };
-    }
-    const arrayObjetNews =  await this.endpointApi.getNews(data);
-    if(!Array.isArray(arrayObjetNews)){
-      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
+  async project(projectData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un projet.");
     }
-    const rawNewsList = arrayObjetNews.map((newsData) =>
-      this.deps.News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
-    );
-
-    return this._createFilteredProxy(rawNewsList);
+    return super.project(projectData);
   }
 
   /**
@@ -474,64 +509,57 @@ export class User {
    * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
    * @throws {Error} Si une erreur se produit lors de la création de la news.
    */
-  async news(newsData = {}, ) {
-    try {
-      const news = new this.deps.News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
-      if (newsData.id) {
-        await news.get();
-      }
-      return news;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.news] Erreur lors de la création d'une instance news :`, error.message);
-      throw error;
+  async news(newsData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une actualité.");
     }
-  }
-
-  _updateInitialDraftSnapshot() {
-    this.#initialDraftData = JSON.parse(JSON.stringify(this.#draftData));
-  }
-
-  // TODO: ne fonctionne pas
-  hasChanges() {
-    return JSON.stringify(this.#draftData) !== JSON.stringify(this.#initialDraftData);
+    return super.news(newsData);
   }
 
   /**
-   * Champs par défaut pour les schemas json ou l'on extrait les fields. (pour les if/else/then)
+   * Crée une instance de POI et la récupère si nécessaire.
    * 
-   * @property {Object} defaultFields - Un objet contenant les propriétés par défaut pour l'entité User.
+   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
+   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
+   * @throws {Error} Si une erreur se produit lors de la création du POI.
    */
-  defaultFields = {
-    typeElement: this.getEntityType(), 
-  };
+  async poi(poiData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un POI.");
+    }
+    return super.poi(poiData);
+  }
 
   /**
-   * Champs à supprimer de draft lors de la construction du proxy.
+   * Crée une instance d'événement et la récupère si nécessaire.
    * 
-   * @property {Array<string>} removeFields - Un tableau de chaînes représentant les champs à supprimer.
+   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
+   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
    */
-  removeFields = [
-    "typeElement",
-  ];
-  
+  async event(eventData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un événement.");
+    }
+    return super.event(eventData);
+  }
+
   /**
-   * Transformateurs appliqués lors de la lecture du draft.
-   *
-   * @type {Object<string, function>}
+   * Crée une instance de badge et la récupère si nécessaire.
+   * 
+   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
+   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
+   * @throws {Error} Si une erreur se produit lors de la création du badge.
    */
-  transforms = {
-    github: (val, full) => full?.socialNetwork?.github,
-    gitlab: (val, full) => full?.socialNetwork?.gitlab,
-    facebook: (val, full) => full?.socialNetwork?.facebook,
-    twitter: (val, full) => full?.socialNetwork?.twitter,
-    instagram: (val, full) => full?.socialNetwork?.instagram,
-    diaspora: (val, full) => full?.socialNetwork?.diaspora,
-    mastodon: (val, full) => full?.socialNetwork?.mastodon,
-    telegram: (val, full) => full?.socialNetwork?.telegram,
-    signal: (val, full) => full?.socialNetwork?.signal
-  };
+  async badge(badgeData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un badge.");
+    }
+    return super.badge(badgeData);
+  }
+
 }
 
 // Incorporation des mixins dans User
-Object.assign(User.prototype, MutualEntityMixin, UtilMixin, UserMixin, DraftStateMixin);
+Object.assign(User.prototype, UserMixin);