@communecter/cocolight-api-client 1.0.21 → 1.0.23

package/src/api/User.js

@@ -81,7 +81,7 @@ export class User extends BaseEntity {
       
     super(parent, data, deps);
   }
-      
+
   get slug() {
     return this._draftData.slug || null;
   }
@@ -90,6 +90,14 @@ export class User extends BaseEntity {
     return this.isConnected && this.userId === this.id;
   }
 
+  get parentIsMe() {
+    return super.isMe;
+  }
+
+  get isActingUser() {
+    return this.parentIsMe && !this.isMe;
+  }
+
   /**
      * Récupère le profil complet de l'utilisateur.
      * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
@@ -181,23 +189,7 @@ export class User extends BaseEntity {
   }
 
   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;
+    return new User(parent.apiClient, data, deps);
   }
 
   /**
@@ -451,6 +443,18 @@ export class User extends BaseEntity {
     return filteredBadges;
   }
 
+  async user(userData) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur");
+    }
+    if (!userData.id && !userData.slug) {
+      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+    const user = new User(this, userData, this.deps);
+    await user.get();
+    return user;
+  }
+
   /**
    * Crée une instance d'organisation et récupère son profil si nécessaire.
    *
@@ -535,6 +539,209 @@ export class User extends BaseEntity {
     return super.badge(badgeData);
   }
 
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ utilisateur (ami)
+   *  (demander, valider, se retirer)
+   * ───────────────────────────────
+   */
+
+  /**
+   * Envoie une demande d'amitié à cet utilisateur.
+   * L'utilisateur ciblé devra valider la demande pour établir la relation.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async sendFriendRequest() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande d'amis.");
+    }
+
+    this._checkLinkableEntity();
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const { connectTypeConnect } = this._getLinkMeta();
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: connectTypeConnect
+      };
+      const retour = await this.endpointApi.connect(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    if (userLink.isInviting && userLink.invitorId === this.id) {
+      return this.acceptFriendRequest();
+    }
+
+    if (userLink.isInviting && userLink.invitorId === this.userId) {
+      throw new ApiError("Vous avez déjà envoyé une demande d'amis à cet utilisateur.");
+    }
+
+    throw new ApiError("Vous êtes déjà connecté à cette entité.");
+  }
+
+  /**
+   * Accepte une demande d'amitié envoyée par cet utilisateur.
+   * Cette action établit un lien entre les deux utilisateurs.
+   *
+   * @returns {Promise<Object>} - Résultat de la validation du lien.
+   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'action est interdite.
+   */
+  async acceptFriendRequest() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour accepter une demande d'amitié.");
+    }
+
+    this._checkLinkableEntity();
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (userLink?.isInviting && userLink.invitorId === this.id) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        linkOption: "isInviting"
+      };
+      const retour = await this.endpointApi.linkValidate(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'avez pas d'invitation à valider.");
+  }
+
+  /**
+   * Supprime la relation d'amitié avec cet utilisateur.
+   * Cette action annule tout lien existant entre les deux profils.
+   *
+   * @returns {Promise<Object>} - Résultat de la suppression.
+   * @throws {ApiError} - Si aucune relation n'existe.
+   */
+  async removeFriend() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour supprimer un ami.");
+    }
+
+    this._checkLinkableEntity();
+    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,
+      connectType: connectTypeDisconnect
+    };
+    const retour = await this.endpointApi.disconnect(data);
+    // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+    await this.parent.refresh();
+    return retour;
+  }
+    
+
+  requestToJoin() {
+    throw new ApiError("l'utilisation de requestToJoin n'est pas autorisée sur un utilisateur.");
+  }
+
+  requestToJoinAdmin() {
+    throw new ApiError("l'utilisation de requestToJoinAdmin n'est pas autorisée sur un utilisateur.");
+  }
+
+  acceptInvitation() {
+    throw new ApiError("l'utilisation de acceptInvitation n'est pas autorisée sur un utilisateur.");
+  }
+
+  leave() {
+    throw new ApiError("l'utilisation de leave n'est pas autorisée sur un utilisateur.");
+  }
+
+  /**
+   * Suivre un utilisateur
+   * Cette action permet à l'utilisateur connecté de suivre un autre utilisateur.
+   * Elle nécessite que l'utilisateur soit connecté.
+   * 
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async follow() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour suivre un utilisateur.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.parent?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id
+      };
+      const retour = await this.endpointApi.follow(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous êtes déjà abonné à cet utilisateur.");
+  }
+
+  /**
+   * Se désabonner d'un utilisateur
+   * Cette action permet à l'utilisateur connecté de se désabonner d'un autre utilisateur.
+   * Elle nécessite que l'utilisateur soit connecté.
+   * 
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async unfollow() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour vous désabonner d'un utilisateur.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.parent?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: "followers"
+      };
+      const retour = await 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.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.");
+  }
+
+
+
 }
 
 // Incorporation des mixins dans User