@communecter/cocolight-api-client 1.0.122 → 1.0.124

package/src/api/Classified.ts

@@ -0,0 +1,171 @@
+import { ApiError } from "../error.js";
+import { BaseEntity } from "./BaseEntity.js";
+import { transformEntityRefs } from "../types/transforms.js";
+
+import type { AddClassifiedData } from "./EndpointApi.types.js";
+import type { ClassifiedItemNormalized } from "./serverDataType/Classified.js";
+
+export class Classified extends BaseEntity<ClassifiedItemNormalized> {
+  static override entityType = "classifieds";
+
+  static override entityTag = "Classified";
+
+  static override SCHEMA_CONSTANTS: string[] = [
+    "ADD_CLASSIFIED",
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_CLASSIFIED", "addClassified"],
+  ] as const);
+
+  override defaultFields: Record<string, unknown> = {
+    typeElement: "classified",
+  };
+
+  override removeFields: string[] = [
+    "typeElement",
+  ];
+
+  // Le serveur enrichit `parent` avec _id/slug/id/profilThumbImageUrl/etc.
+  // qui ne sont pas dans le schéma d'envoi (additionalProperties: false → name, type seuls).
+  // On filtre via transformEntityRefs à la construction du draft pour rester compatible
+  // côté update (pattern identique à Event.transforms).
+  override transforms: Record<string, (val: any, full?: any) => any> = {
+    parent: transformEntityRefs,
+  };
+
+  override _add = async (payload: Record<string, unknown>): 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(Classified.ADD_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await (this as any)[methodName](blockData);
+        if (!this.id && data?.map?.id) {
+          this._draftData.id = data.map.id;
+          this._draftData.slug = data.map.slug;
+        }
+      }
+    }
+  };
+
+  // L'endpoint /co2/element/save (ADD_CLASSIFIED) gère création ET mise à jour selon que
+  // l'id existe ou pas côté serveur. On réutilise donc le même schéma pour valider les
+  // champs en update (pattern identique à Event._update).
+  // Droit de modifier : auteur du classified OU admin d'un parent (orga/projet) si le
+  // classified est rattaché.
+  override _update = async (payload: Record<string, unknown>): Promise<boolean> => {
+    if (!this._calledFromSave) {
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
+    }
+    if (!this.isAuthor() && !this.isAdmin({ checkHierarchy: true })) {
+      throw new ApiError("Vous n'êtes pas autorisé à modifier cette ressource", 403);
+    }
+
+    let hasChanged = false;
+
+    const blockData = this._extractAllValidFieldsFromSchema(
+      this.apiClient,
+      "ADD_CLASSIFIED",
+      { ...payload, ...this.defaultFields },
+      () => this.initialDraftData,
+      this.removeFields
+    );
+    if (blockData && Object.keys(blockData).length > 0) {
+      await this.addClassified(blockData);
+      hasChanged = true;
+    }
+
+    return hasChanged;
+  };
+
+  async addClassified(data: Partial<AddClassifiedData> = {}): Promise<unknown> {
+    // Si le parent direct n'est pas l'utilisateur connecté (ex: création via une org),
+    // on injecte le parent dans le payload. Sans ça, le default schéma `{ "@userId": ... }`
+    // pose me comme parent — ce qui est faux pour `me.org().classified()`.
+    // NB: this.isMe est trompeur ici car userContext propage jusqu'au User connecté
+    // (donc isMe=true même quand le parent direct est une org).
+    // Si le caller fournit déjà `data.parent`, on respecte sa valeur (pas de merge automatique).
+    const parentData = data as Record<string, unknown>;
+    if (this.parent && this.parent.id && this.parent.id !== this.userId && !parentData.parent) {
+      parentData.parent = {};
+      const parentMap = parentData.parent as Record<string, unknown>;
+      parentMap[`${this.parent.id}`] = {
+        type: this.parent.getEntityType(),
+        name: (this.parent as unknown as Record<string, unknown>).name,
+      };
+    }
+
+    return this.callIsConnected(() => this.endpointApi.addClassified(data as AddClassifiedData));
+  }
+
+  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);
+  }
+
+  override async getEvents(): Promise<never> {
+    throw new ApiError(`getEvents n'existe pas 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);
+  }
+
+  override async getNews(): Promise<never> {
+    throw new ApiError(`getNews n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  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(`event n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async badge(): Promise<never> {
+    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async news(): Promise<never> {
+    throw new ApiError(`news n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async classified(): Promise<never> {
+    throw new ApiError(`classified n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async follow(): Promise<never> {
+    throw new ApiError(`follow n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async unfollow(): Promise<never> {
+    throw new ApiError(`unfollow n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  override async getGallery(): Promise<never> {
+    throw new ApiError(`getGallery n'existe pas dans ${this.constructor.name}`, 501);
+  }
+}