[ERP-55] ClientProvider + ClientProcessor + RG métier (M1) — stackée sur ERP-54 (#31)

**MR stackée sur ERP-54** — cible = `feature/ERP-54-creer-entites-client-m1` (PAS `develop`). Tristan validera le stack en fin de chaîne. Branche l'API REST du répertoire clients (M1) sur l'entité `Client` d'ERP-54. ## Périmètre - **ClientProvider** : liste paginée (Paginator ORM aligné ERP-72, `?pagination=false`), exclusion archives+soft-delete par défaut (RG-1.24), `?includeArchived=true` (RG-1.25), tri `companyName ASC` (RG-1.26), filtres `?search` (fuzzy) + `?categoryType`, détail 404 si soft-deleted + embarque contacts/adresses/ribs. - **ClientProcessor** : normalisation (RG-1.18→1.21), 409 doublon nom (RG-1.16) + 409 restauration (RG-1.23), gating par onglet `accounting.manage`/`archive` + mode strict 403 (RG-1.28), archivage exclusif + `archivedAt` (RG-1.22), RG-1.01 / RG-1.03 (mutex + type catégorie) / RG-1.12 / RG-1.13 / RG-1.04. - **ClientReadGroupContextBuilder** : ajout conditionnel du groupe `client:read:accounting` selon `commercial.clients.accounting.view`. - **CategoryReferenceDenormalizer** : résout les IRI catégorie vers `Category` (dénormalisation impossible sur l'interface sinon). - **Contrats Shared** : `CategoryInterface::getCategoryTypeCode()`, `BusinessRoleAwareInterface` + `BusinessRoles::COMMERCIALE`. ## Coordination stack - Permissions `commercial.clients.*` **référencées** ici, déclarées en **ERP-59** (tests RBAC en **ERP-60**). - Rôle métier `commerciale` seedé par **ERP-74** (RG-1.04 dormante d'ici là). - Config globale pagination (itemsPerPage client / max 50) portée par **ERP-72**. - Référentiels comptables (PaymentType/Bank/...) exposés en **ERP-56** → RG-1.12/1.13 testées en unitaire ici (pas d'IRI référentiel disponible avant ERP-56). ## Tests 31 tests Commercial (intégration admin sur les RG métier + unitaires sur le gating / RG-1.04 / RG-1.12 / RG-1.13 / context builder). Suite complète verte (343 tests). Règle n°1 respectée (aucun import inter-modules dans Commercial). --------- Co-authored-by: tristan <tristan@yuno.malio.fr> Co-authored-by: Matthieu <contact@malio.fr> Co-authored-by: Matthieu <mtholot19@gmail.com> Reviewed-on: #31 Co-authored-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr> Co-committed-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr>
2026-06-01 19:28:04 +00:00
parent b495e4030a
commit 0c9b563cae
18 changed files with 2085 additions and 4 deletions
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\Serializer;
+
+use ApiPlatform\Metadata\IriConverterInterface;
+use App\Shared\Domain\Contract\CategoryInterface;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * Denormalise un IRI (`/api/categories/{id}`) vers la Category concrete quand la
+ * propriete cible est type-hintee par le contrat CategoryInterface (ex:
+ * Client::$categories, ClientAddress::$categories).
+ *
+ * Pourquoi ce denormalizer : API Platform deduit le type de l'element de
+ * collection depuis le phpdoc `@var Collection<int, CategoryInterface>`, donc
+ * l'INTERFACE. Or le serializer ne sait pas denormaliser un IRI vers une
+ * interface (« Could not denormalize object of type CategoryInterface[] ») : il
+ * lui faut une classe-ressource concrete. On resout donc l'IRI via l'IriConverter
+ * (qui retourne la Category mappee a la route) sans importer Category — la regle
+ * ABSOLUE n°1 reste respectee (dependance au seul contrat Shared + API Platform).
+ *
+ * En lecture (normalisation), aucun probleme : l'objet reel EST une Category,
+ * resource a part entiere, serialisee en IRI par le normalizer standard.
+ */
+final class CategoryReferenceDenormalizer implements DenormalizerInterface
+{
+    public function __construct(
+        private readonly IriConverterInterface $iriConverter,
+    ) {}
+
+    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): ?CategoryInterface
+    {
+        if (!is_string($data) || '' === $data) {
+            return null;
+        }
+
+        // getResourceFromIri leve une exception sur IRI invalide -> 400, ce qui
+        // est le comportement attendu pour une reference cassee.
+        $resource = $this->iriConverter->getResourceFromIri($data);
+
+        // IRI syntaxiquement valide mais pointant sur une autre ressource (ex:
+        // '/api/clients/5' la ou une categorie est attendue) : on refuse
+        // explicitement plutot que de retourner null silencieusement, ce qui
+        // perdrait la reference sans erreur. UnexpectedValueException -> 400.
+        if (!$resource instanceof CategoryInterface) {
+            throw new UnexpectedValueException(sprintf(
+                'L\'IRI "%s" ne référence pas une catégorie.',
+                $data,
+            ));
+        }
+
+        return $resource;
+    }
+
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
+    {
+        // Support base sur le seul type cible : l'ArrayDenormalizer (collection
+        // `CategoryInterface[]`) interroge le support en passant le TABLEAU
+        // complet comme $data avant de deleguer element par element. Tester
+        // is_string($data) ici casserait donc la chaine pour les collections.
+        return CategoryInterface::class === $type;
+    }
+
+    /**
+     * @return array<class-string|string, bool>
+     */
+    public function getSupportedTypes(?string $format): array
+    {
+        return [CategoryInterface::class => true];
+    }
+}
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\Serializer;
+
+use ApiPlatform\State\SerializerContextBuilderInterface;
+use App\Module\Commercial\Domain\Entity\Client;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
+use Symfony\Component\DependencyInjection\Attribute\AutowireDecorated;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Decore le context builder de serialisation d'API Platform pour ajouter
+ * DYNAMIQUEMENT le groupe de lecture `client:read:accounting` sur les ressources
+ * Client, uniquement si l'utilisateur courant a la permission
+ * `commercial.clients.accounting.view` (cf. spec-back M1 § 2.7 / § 4.1 / § 4.2).
+ *
+ * Pourquoi un context builder et pas le Provider : un Provider retourne des
+ * donnees mais ne peut pas influencer les groupes de serialisation. Le contexte
+ * de normalisation est construit ici, en amont du serializer — c'est le point
+ * d'extension idiomatique d'API Platform pour conditionner un groupe selon
+ * l'utilisateur. Realise l'intention « ajout conditionnel du groupe accounting »
+ * de la spec.
+ *
+ * S'applique aux operations de LECTURE (normalization) sur Client : liste ET
+ * detail. Sans la permission, les champs comptables (siren, accountNumber,
+ * tvaMode, nTva, paymentDelay, paymentType, bank) ne sont jamais serialises.
+ */
+#[AsDecorator('api_platform.serializer.context_builder')]
+final readonly class ClientReadGroupContextBuilder implements SerializerContextBuilderInterface
+{
+    public function __construct(
+        #[AutowireDecorated]
+        private SerializerContextBuilderInterface $decorated,
+        private Security $security,
+    ) {}
+
+    public function createFromRequest(Request $request, bool $normalization, ?array $extractedAttributes = null): array
+    {
+        $context = $this->decorated->createFromRequest($request, $normalization, $extractedAttributes);
+
+        // Uniquement en lecture, sur la ressource Client, avec la permission.
+        if (!$normalization) {
+            return $context;
+        }
+
+        if (Client::class !== ($context['resource_class'] ?? null)) {
+            return $context;
+        }
+
+        if (!$this->security->isGranted('commercial.clients.accounting.view')) {
+            return $context;
+        }
+
+        $groups = $context['groups'] ?? [];
+        if (!in_array('client:read:accounting', $groups, true)) {
+            $groups[] = 'client:read:accounting';
+        }
+        $context['groups'] = $groups;
+
+        return $context;
+    }
+}