@communecter/cocolight-api-client 1.0.142 → 1.0.144

package/src/api/Poi.ts

@@ -3,8 +3,38 @@ import { BaseEntity } from "./BaseEntity.js";
 import { PoiItemNormalized } from "./serverDataType/Poi.js";
 import { transformEntityRefs } from "../types/transforms.js";
 
+import type { SetTypeValue } from "./BaseEntity.js";
 import type { AddPoiData } from "./EndpointApi.types.js";
 
+/**
+ * Source unique des champs « équipement sportif » (RES) éditables sur le POI :
+ *  - `schema`  : type JSON → alimente le VIRTUAL_SCHEMA (draft-allow + cohérence des types)
+ *  - `setType` : coercion backend pour `UPDATE_PATH_VALUE` (absent = string/array)
+ * On en dérive `Poi.VIRTUAL_SCHEMAS`, `Poi.CUSTOM_FIELD_HANDLERS` et `Poi.EQUIPMENT_SETTYPE`.
+ */
+const POI_EQUIPMENT_FIELDS: ReadonlyArray<{ name: string; schema: Record<string, unknown>; setType?: SetTypeValue }> = [
+  // Nombres (dimensions)
+  ...["equip_surf", "equip_larg", "equip_long"].map((name) => ({ name, schema: { type: "number" }, setType: "float" as SetTypeValue })),
+  // Dates (string côté schéma, normalisées en Date à la lecture ; isoDate à l'écriture)
+  ...["equip_maj_date", "inst_date_creation", "inst_enqu_date"].map((name) => ({ name, schema: { type: "string" }, setType: "isoDate" as SetTypeValue })),
+  // Booléens
+  ...[
+    "inst_acc_handi_bool", "inst_trans_bool", "equip_eclair", "equip_acc_libre", "inst_part_bool",
+    "equip_pmr_acc", "equip_pmr_chem", "equip_pmr_douche", "equip_pmr_sanit", "equip_pmr_trib", "equip_pmr_vest",
+    "equip_pshs_aire", "equip_pshs_chem", "equip_pshs_sanit", "equip_pshs_trib", "equip_pshs_vest", "equip_pshs_sign",
+    "equip_douche"
+  ].map((name) => ({ name, schema: { type: "boolean" }, setType: "bool" as SetTypeValue })),
+  // Strings
+  ...[
+    "categorie", "equip_type_name", "inst_nom", "equip_type_famille", "equip_nature", "equip_sol",
+    "inst_acc_handi_type", "inst_trans_type", "equip_prop_nom", "equip_prop_type", "equip_gest_type"
+  ].map((name) => ({ name, schema: { type: "string" } })),
+  // Arrays de strings
+  ...[
+    "aps_name", "inst_part_type", "equip_loc_type", "equip_utilisateur"
+  ].map((name) => ({ name, schema: { type: "array", items: { type: "string" } } }))
+];
+
 export class Poi extends BaseEntity<PoiItemNormalized> {
   static override entityType = "poi";
 
@@ -16,7 +46,8 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     "UPDATE_BLOCK_INFO",
     "UPDATE_BLOCK_LOCALITY",
     "UPDATE_BLOCK_SLUG",
-    "PROFIL_IMAGE"
+    "PROFIL_IMAGE",
+    "VIRTUAL_POI_EQUIPMENT"
   ];
 
   static ADD_BLOCKS = new Map([
@@ -32,6 +63,30 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     ["PROFIL_IMAGE", "updateImageProfil"]
   ] as const);
 
+  /**
+   * Champs « équipement sportif » (RES) éditables hors `UPDATE_BLOCK_*` : déclarés en
+   * VIRTUAL_SCHEMA (autorise l'écriture sur le draft + fixe les types) et persistés à
+   * l'update via `CUSTOM_FIELD_HANDLERS` → `updateEquipmentField` → `UPDATE_PATH_VALUE`.
+   * Même pattern qu'`Organization`/`Action`. (Ils restent aussi dans `ADD_POI` pour la création.)
+   */
+  static override VIRTUAL_SCHEMAS = {
+    VIRTUAL_POI_EQUIPMENT: {
+      type: "object",
+      properties: Object.fromEntries(POI_EQUIPMENT_FIELDS.map((f) => [f.name, f.schema]))
+    }
+  };
+
+  static override CUSTOM_FIELD_HANDLERS = new Map(
+    POI_EQUIPMENT_FIELDS.map((f) =>
+      [f.name, { updateMethod: "updateEquipmentField", schemaConstant: "VIRTUAL_POI_EQUIPMENT" }] as [string, { updateMethod: string; schemaConstant?: string }]
+    )
+  );
+
+  /** setType backend par champ équipement (consommé par `updateEquipmentField`). */
+  private static readonly EQUIPMENT_SETTYPE = new Map<string, SetTypeValue | undefined>(
+    POI_EQUIPMENT_FIELDS.map((f) => [f.name, f.setType])
+  );
+
   override defaultFields: Record<string, any> = {
     typeElement: this.getEntityType()
   };
@@ -83,6 +138,23 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     if (payload.id) delete payload.id;
     let hasChanged = false;
 
+    // 1. Champs équipement (RES) : non couverts par les UPDATE_BLOCK_*. Persistés
+    //    individuellement via CUSTOM_FIELD_HANDLERS -> updateEquipmentField -> UPDATE_PATH_VALUE
+    //    (même mécanisme qu'Organization/Action).
+    const customHandlers = Poi.CUSTOM_FIELD_HANDLERS;
+    if (customHandlers) {
+      const processedFields = new Set<string>();
+      for (const [fieldName, config] of customHandlers) {
+        if (fieldName in payload && this._hasFieldChanged(fieldName)) {
+          await this._invokeCustomFieldHandler(config.updateMethod, payload[fieldName], fieldName);
+          processedFields.add(fieldName);
+          hasChanged = true;
+        }
+      }
+      processedFields.forEach((f) => delete payload[f]);
+    }
+
+    // 2. Blocs standards (description, info, locality, slug, image).
     for (const [constant, methodName] of Array.from(Poi.UPDATE_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
@@ -100,6 +172,34 @@ export class Poi extends BaseEntity<PoiItemNormalized> {
     return hasChanged;
   };
 
+  /**
+   * Handler générique des champs « équipement sportif » (RES), enregistré dans
+   * `CUSTOM_FIELD_HANDLERS`. Persiste un champ via `UPDATE_PATH_VALUE` avec le `setType`
+   * adéquat (lu dans `EQUIPMENT_SETTYPE`). `fieldName` est fourni par `_invokeCustomFieldHandler`.
+   *
+   * Effacement façon `Action` : `null`/`""` → on envoie `""` SANS `setType` → le backend fait
+   * `!empty($value)` → `$unset` (sinon `floatval("")=0` écraserait au lieu d'effacer).
+   */
+  async updateEquipmentField(value: unknown, fieldName: string): Promise<unknown> {
+    const setType = Poi.EQUIPMENT_SETTYPE.get(fieldName);
+    const isClear = value === null || value === "";
+    return this.updateField(fieldName, isClear ? "" : value, isClear || !setType ? {} : { setType });
+  }
+
+  /**
+   * Override confiné à `Poi` : forwarde `fieldName` au handler (2e argument) pour permettre
+   * un handler générique unique (`updateEquipmentField`) couvrant les ~39 champs équipement,
+   * sans toucher `BaseEntity._invokeCustomFieldHandler` (utilisé par les autres entités, qui
+   * ne passent que `value`). Copie volontaire du corps de base + le forward du `fieldName`.
+   */
+  protected override async _invokeCustomFieldHandler(methodName: string, value: any, fieldName: string): Promise<any> {
+    const method = (this as any)[methodName];
+    if (typeof method !== "function") {
+      throw new ApiError(`Custom handler "${methodName}" not found for field "${fieldName}"`, 500);
+    }
+    return await method.call(this, value, fieldName);
+  }
+
   async addPoi(data: Partial<AddPoiData> = {}): Promise<unknown> {
 
     // Si le parent direct n'est pas l'utilisateur connecté (ex: création via une org),

package/src/api/Project.ts

@@ -74,13 +74,16 @@ export class Project extends BaseEntity<ProjectItemNormalized> {
     if (rawAnswers && typeof rawAnswers === "object") {
       const linkedAnswers: Record<string, unknown[]> = {};
       for (const [formId, docs] of Object.entries(rawAnswers)) {
-        if (Array.isArray(docs)) {
-          linkedAnswers[formId] = docs.map((doc) =>
-            doc && typeof doc === "object"
-              ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
-              : doc
-          );
-        }
+        // Le backend renvoie tantôt un tableau `[doc, ...]`, tantôt une map indexée
+        // par id `{ answerId: doc }`. On normalise vers un tableau dans les deux cas.
+        const list = Array.isArray(docs)
+          ? docs
+          : (docs && typeof docs === "object" ? Object.values(docs) : []);
+        linkedAnswers[formId] = list.map((doc) =>
+          doc && typeof doc === "object"
+            ? this._linkEntity("answers", { ...(doc as Record<string, unknown>), collection: "answers" })
+            : doc
+        );
       }
       (data as Record<string, unknown>).answers = linkedAnswers;
     }

package/src/api/User.ts

@@ -17,6 +17,7 @@ import type {
   GetSubscriptionsData,
   GetOrganizationsNoAdminData,
   GetOrganizationsAdminData,
+  GetUserEligiblePlacesData,
   GetFriendsAdminData,
   DemoteAdminData,
   GetNotificationsData,
@@ -410,6 +411,59 @@ export class User extends BaseEntity<UserItemNormalized> {
     return paginator.next() as Promise<PaginatorPage<Organization>>;
   }
 
+  /**
+   * Récupère les lieux (organizations) memberOf de l'utilisateur, filtrés
+   * côté serveur par des filters arbitraires (tags, source.key, etc.) et
+   * un flag `notSourceKey` configurables.
+   *
+   * Mirroir de `getOrganizations` mais permet de passer dynamiquement les
+   * filtres du finder du formulaire (vue collaborative coform/place), pour
+   * que la pagination soit correcte (filtrage côté serveur, pas côté client).
+   *
+   * Constant : GET_USER_ELIGIBLE_PLACES
+   */
+  async getEligiblePlaces(
+    data: Partial<GetUserEligiblePlacesData> = {},
+    options?: { restoredState?: PaginatorState }
+  ) {
+    // Force le default `searchType` ([NGO, Cooperative, ...]) — le PHP ne
+    // retourne rien si le tableau est vide / absent. Pattern aligné avec
+    // `getOrganizations`.
+    data.searchType = this._getDefaultFromEndpoint(
+      "GET_USER_ELIGIBLE_PLACES",
+      "searchType"
+    ) as GetUserEligiblePlacesData["searchType"];
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      methodName: "getEligiblePlaces",
+      restoredState: options?.restoredState,
+      finalizer: async (finalData) => {
+        delete finalData?.pathParams;
+
+        // Auto-merge du filtre memberOf par défaut si l'appelant n'en pousse
+        // que des filters "métier" (tags, etc.). On garde la sémantique
+        // "uniquement les orgs où l'user est membre validé".
+        const userFilters = finalData.filters ?? {};
+        const memberOfDefaults: Record<string, unknown> = {
+          [`links.members.${this.id}`]: { "$exists": true },
+          [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+          [`links.members.${this.id}.isInviting`]: { "$exists": false },
+        };
+        finalData.filters = { ...memberOfDefaults, ...userFilters };
+
+        // Cast nécessaire : callIsMe est typé Promise<unknown>, mais l'endpoint
+        // retourne bien la shape `{ results, count }` attendue par le finalizer.
+        // Pattern aligné avec getOrganizations (cf. la branche ternaire au-dessus).
+        return this.callIsMe(() => this.endpointApi.getUserEligiblePlaces(finalData)) as ReturnType<
+          typeof this.endpointApi.getUserEligiblePlaces
+        >;
+      },
+    });
+
+    return paginator.next() as Promise<PaginatorPage<Organization>>;
+  }
+
   /**
    * {@inheritDoc BaseEntity#getProjects}
    * 

package/src/api/serverDataType/Form.ts

@@ -134,3 +134,24 @@ export interface FormItemNormalized {
     useBannerImg?: boolean;
     [key: string]: unknown;
 }
+
+/**
+ * Une contribution individuelle à une table commune (commonTable) d'un coform.
+ * Retournée par `Form.getCommonTableContributors()` (endpoint GET_COFORM_COMMONTABLE_CONTRIBUTORS).
+ * Plusieurs entrées possibles pour un même `userId` (plusieurs solutions au même usage).
+ */
+export interface CoformCommonTableContributor {
+  userId: string;
+  userName?: string;
+  userSlug?: string;
+  criteriaId: string;
+  /** Nom de la solution saisie. */
+  criteria: string;
+  /** love | happySmile | neutral | sad | cry | "" */
+  happiness?: string;
+  /** Note de 0 à 5. */
+  note?: number;
+  comment?: string;
+  fromAnswerId?: string;
+  [k: string]: unknown;
+}