diff --git a/config/modules.php b/config/modules.php index c4f8f54..1681bb8 100644 --- a/config/modules.php +++ b/config/modules.php @@ -5,10 +5,12 @@ use App\Module\Catalog\CatalogModule; use App\Module\Commercial\CommercialModule; use App\Module\Core\CoreModule; use App\Module\Sites\SitesModule; +use App\Module\Technique\TechniqueModule; return [ CoreModule::class, CommercialModule::class, SitesModule::class, CatalogModule::class, + TechniqueModule::class, ]; diff --git a/config/packages/doctrine.yaml b/config/packages/doctrine.yaml index 5aeb29c..a6a4377 100644 --- a/config/packages/doctrine.yaml +++ b/config/packages/doctrine.yaml @@ -80,6 +80,16 @@ doctrine: dir: '%kernel.project_dir%/src/Module/Commercial/Domain/Entity' prefix: 'App\Module\Commercial\Domain\Entity' alias: Commercial + # Mapping inconditionnel du module Technique (meme logique que Commercial) : + # les tables prestataires (provider + sous-collections + jointures M2M) + # creees par la migration M3 (Version20260612100000) doivent etre connues + # de l'ORM. L'activation fonctionnelle passe par config/modules.php. + Technique: + type: attribute + is_bundle: false + dir: '%kernel.project_dir%/src/Module/Technique/Domain/Entity' + prefix: 'App\Module\Technique\Domain\Entity' + alias: Technique controller_resolver: auto_mapping: false diff --git a/docs/specs/M3-prestataires/spec-back.md b/docs/specs/M3-prestataires/spec-back.md new file mode 100644 index 0000000..b9a1dbd --- /dev/null +++ b/docs/specs/M3-prestataires/spec-back.md @@ -0,0 +1,1013 @@ +--- +# === IDENTITÉ === +module: M3 +nom: "Répertoire prestataires" +ecran: repertoire-prestataires +owner_spec: Matthieu +backup_spec: Tristan +version: V0.2 +date_redaction: 2026-06-11 +# Historique : V0.2 (2026-06-11) — Spec back initiale, miroir M2 (fournisseurs). +# Alignement refonte-contact (pas de contact inline sur le formulaire principal). +# Différences M3 : pas d'onglet Information ; site sur le formulaire principal (provider_site) ; +# adresse simple (pas de type/bennes/triage) ; nouveau pôle Technique. + +# === LIENS === +spec_front: ./spec-front.md +maquette_figma: "https://www.figma.com/design/jRYgT0T9c03VsEbjGhCwwS/Composants---Design-System?node-id=1132-42090&p=f&m=dev" + +# === LIEN LESSTIME === +lesstime_taskgroup_id: 29 # M3 — Répertoire prestataires (projet STARSEED #6) +lesstime_project_id: 6 +statut_global: en_dev + +# === DÉPENDANCES AMONT === +depend_de: + - M2-suppliers # pattern jumeau Supplier* répliqué en Provider* ; référentiels compta partagés + - M1-clients # référentiels comptables (TvaMode/PaymentDelay/PaymentType/Bank) + filtre ?typeCode= (créé au M2) + - M0-categories # Category + CategoryType (étendu par seed M3 : type PRESTATAIRE) + - Sites # SitesModule + 3 sites seedés (86 / 17 / 82) déjà en place + - Core # User, Role, Permission, Audit, JWT déjà en place + - Shared # TimestampableBlamableTrait + Subscriber (ERP-52) +--- + +# Spec back — Module 3 : Répertoire prestataires + +## 1. Contexte + +Cette spec **complète et précise** la [spec front V0.2](./spec-front.md) (`M3-reportoire-prestataires.docx` du 04/06/2026) avec tout ce qui touche au back : décisions d'archi, modèle de données, migration, API REST, RBAC, règles de gestion, tests, hors-périmètre. + +**Module cible** : **nouveau module `Technique`** (`src/Module/Technique/`). Le prestataire est le **jumeau du fournisseur** (`Provider` / `ProviderContact` / `ProviderAddress` / `ProviderRib`), construit sur le pattern éprouvé M1/M2. Voir § 2.1 pour la justification du module séparé et la consommation des référentiels comptables. + +**Dépendances déjà en place sur `develop`** (héritées M1/M2) : +- `Commercial` → référentiels comptables `TvaMode` / `PaymentDelay` / `PaymentType` / `Bank` (entités lecture seule, déjà seedées — **partagées sans duplication**, consommées en relation ORM). +- `Catalog` (M0) → `Category` + `CategoryType` + **filtre `?typeCode=` opérationnel** (créé au M2). Le M3 ajoute le type `PRESTATAIRE`. +- `Sites` → 3 sites Châtellerault (86) / Saint-Jean (17) / Pommevic (82). +- `Shared` → `TimestampableBlamableTrait` + `Subscriber` (ERP-52). +- `Core` → User, Role, Permission, Audit, JWT. + +> **RETEX obligatoire** : lire [`../_RETEX-M1-pour-M2.md`](../_RETEX-M1-pour-M2.md) AVANT de coder. ~80 % des frictions M1 venaient du **contrat de sérialisation** (groupes / sous-ressources / embed), pas du métier. La section § 4.0 applique ce RETEX au M3. + +## 2. Décisions d'archi + +### 2.1 Module — Nouveau module `Technique`, entités jumelles de `Supplier` + +> **⚠️ Décision à confirmer (Matthieu, 11/06/2026)** : le docx place le répertoire prestataires dans un **Module « Technique »**, confirmé comme **pôle distinct du Commercial**. On crée donc un **nouveau module back `Technique`** : +> - `src/Module/Technique/TechniqueModule.php` : `ID = 'technique'`, `LABEL = 'Technique'`, `REQUIRED = false`, méthode `permissions()` (cf. § 5.1). +> - Activation : ajouter `TechniqueModule::class` dans `config/modules.php`. +> - Front : layer Nuxt `frontend/modules/technique/` (auto-détecté) + nouvelle **section sidebar « Technique »** dans `config/sidebar.php`. + +Le prestataire M3 **réplique à l'identique** le pattern `Supplier*` du M2 sous `Provider*` (tables dédiées, pas de table polymorphe partagée — clients / fournisseurs / prestataires divergent fonctionnellement, l'isolation prime). + +**Référentiels comptables & Category — consommation cross-module (relation ORM partagée, PAS d'import de logique)** : `Provider` référence `TvaMode` / `PaymentDelay` / `PaymentType` / `Bank` (module Commercial) et `Category` / `Site` (modules Catalog / Sites) via des **relations ORM** (ManyToOne / ManyToMany), **exactement comme `Supplier` (Commercial) référence déjà `Site` (Sites) et `Category` (Catalog)**. Ce sont des **données de référence partagées**, pas de la logique inter-module : aucun service / repository d'un autre module n'est appelé. La règle ABSOLUE n°1 (« ne jamais importer d'un module à un autre — passer par Shared/Contract ») vise les **dépendances de logique métier** ; le projet a déjà acté (M1/M2) que la **référence ORM à une entité de référence partagée** est tolérée et documentée comme telle. + +> **Décision Matthieu (11/06) : on fait « comme supplier »** — consommation ORM partagée des référentiels comptables (zéro refacto, zéro duplication). La remontée dans `Shared` (isolation stricte) reste une option future non retenue au M3 (tracé HP-M4-2). + +### 2.2 IDs entier auto-increment Postgres natif + +Cohérent avec M0/M1/M2 et l'ensemble Starseed. Pas d'UUID, pas de ULID. PK en `INT GENERATED BY DEFAULT AS IDENTITY` (style aligné M1/M2), horodatages en `TIMESTAMP(0) WITHOUT TIME ZONE` (le `TimestampableBlamableTrait` mappe `datetime_immutable`). + +### 2.3 Référentiels comptables — réutilisation M1/M2 (zéro duplication) + +Les 4 tables `tva_mode` / `payment_delay` / `payment_type` / `bank` (+ entités lecture seule et seeds) sont **celles du M1**. Le M3 ne crée **aucune** nouvelle table de référentiel comptable : `provider.tva_mode_id`, `provider.payment_delay_id`, `provider.payment_type_id`, `provider.bank_id` pointent vers les mêmes tables. + +Endpoints : `GET /api/tva_modes`, `/api/payment_delays`, `/api/payment_types`, `/api/banks` existent déjà. **Évolution M3** : élargir leur `security` pour autoriser **aussi** les rôles prestataires (cf. § 4.7). Les codes pivots `VIREMENT` (RG-3.07) et `LCR` (RG-3.08) existent déjà dans `payment_types`. + +### 2.4 Catégories — nouveau `CategoryType` `PRESTATAIRE` + +Le multi-select « Catégorie » du prestataire (formulaire principal ET adresse) référence des `Category` rattachées à un **nouveau `CategoryType` de code `PRESTATAIRE`** (label « Prestataire »), seedé par le M3. On assume des **types distincts** (`CLIENT` / `FOURNISSEUR` / `PRESTATAIRE`) — chacun avec sa taxonomie. + +> **Bonne nouvelle vs M2** : le **filtre `?typeCode=` a été implémenté au M2** sur `/api/categories` (module Catalog). Le M3 n'a donc **plus à le créer** : il suffit de **seeder le type `PRESTATAIRE`** + ses catégories (migration `ON CONFLICT` pour la prod + fixture idempotente pour survivre au purger en dev/test — cf. M2 § 3.2). **À vérifier sur le JSON réel** que `GET /api/categories?typeCode=PRESTATAIRE` filtre bien (DoD de la spec). + +> **Forme réelle de `Category`** : expose `code` **et `name`** (PAS `label`) sous `category:read`, plus `categoryType{ id, code, label }`. Le **libellé affiché front = `category.name`**. Les M2M `provider_category` / `provider_address_category` ne contraignent que des `Category` de type `PRESTATAIRE` (RG-3.09). + +### 2.5 Archive vs soft delete — deux mécanismes distincts (identique M1/M2) + +| Mécanisme | Colonne | Visibilité défaut | Restauration | Utilisateur | +|---|---|---|---|---| +| **Archive** (fonctionnel) | `is_archived` (bool, default false) + `archived_at` | masqué | Oui (toggle UI) | **Admin seul** via `technique.providers.archive` | +| **Soft delete** (technique) | `deleted_at` (timestamptz nullable) | masqué | HP M4+ | Aucun rôle au M3 (HP) | + +Conséquences (miroir M2) : +- `DELETE /api/providers/{id}` **non exposé** au M3 (404 si appelé). +- `GET /api/providers?includeArchived=true` permet de voir les archivés (permission `technique.providers.view`). +- PATCH `{ "isArchived": true }` archive ; PATCH `{ "isArchived": false }` restaure. +- L'unicité métier ignore les archivés ET les soft-deletés (cf. § 2.6). + +### 2.6 Unicité partielle Postgres — nom de société + +> **Décision à confirmer (alignée Q4 M1 / § 2.6 M2)** : l'unicité métier porte **uniquement sur le nom de prestataire** (`company_name`). Le SIREN et l'email principal ne sont **pas** uniques. + +Index unique partiel (`WHERE is_archived = FALSE AND deleted_at IS NULL`) sur `LOWER(company_name)`. Doublon → `409 Conflict` géré par le `ProviderProcessor`. + +### 2.7 Audit & traces temporelles + +Pattern Starseed standard, miroir M1/M2 : +- `#[Auditable]` sur `Provider`, `ProviderContact`, `ProviderAddress`, `ProviderRib`. +- **Tous les champs auditables** (pas d'`#[AuditIgnore]`) — y compris `ProviderRib.iban` et `ProviderRib.bic` (audit admin-only côté Starseed → traçabilité comptable). +- Audit M2M automatique sur `provider.categories` et `provider.sites` (`{categories: {added:[...], removed:[...]}}`). +- **Libellés i18n** (règle ABSOLUE backend — `AuditableEntitiesHaveI18nLabelTest`) : ajouter `audit.entity.technique_provider`, `audit.entity.technique_providercontact`, `audit.entity.technique_provideraddress`, `audit.entity.technique_providerrib` dans `frontend/i18n/locales/fr.json` (clé = `strtolower(module)` + `_` + `strtolower(Entity)`). + +### 2.8 Timestampable + Blamable + +`Provider`, `ProviderContact`, `ProviderAddress`, `ProviderRib` implémentent `TimestampableInterface` + `BlamableInterface` et utilisent `TimestampableBlamableTrait`. Migration : 4 colonnes par table (`created_at`/`updated_at` NOT NULL, `created_by`/`updated_by` nullable `ON DELETE SET NULL`) + commentaires via le helper `addStandardTimestampableBlamableComments($schema, '')`. + +### 2.9 Permissions RBAC — granularité (5 permissions, identique M2) + +| Permission | Admin | Bureau | Compta | Commerciale | Usine | +|---|---|---|---|---|---| +| `technique.providers.view` | ✅ | ✅ | ✅ | ✅ (sauf compta) | ✅ (cloisonné par site — § 2.13) | +| `technique.providers.manage` | ✅ | ✅ | ❌ | ✅ | ❌ | +| `technique.providers.accounting.view` | ✅ | ❌ | ✅ | ❌ | ❌ | +| `technique.providers.accounting.manage` | ✅ | ❌ | ✅ | ❌ | ❌ | +| `technique.providers.archive` | ✅ | ❌ | ❌ | ❌ | ❌ | + +Notes (miroir M2) : +- **Compta édite uniquement l'onglet Comptabilité** (`accounting.manage`) d'un prestataire existant. Pas de création (pas de `manage` global). +- **Commerciale** : `view` + `manage` mais **pas** `accounting.view` → onglet Comptabilité masqué (front) et filtré (back) via le `ProviderReadGroupContextBuilder` (gating **par ajout** de groupe `provider:read:accounting`, jamais par retrait). Sans la permission, scalaires compta + `ribs` ne sont jamais sérialisés. +- **Bureau** : `view` + `manage` (tout sauf Comptabilité). +- **Usine** : `view` (lecture seule, pas de `manage`), **cloisonné par site** — voir § 2.13. +- **⚠️ Le « Tout » vs « son site uniquement » de la colonne Consultation du docx n'est PAS porté par le rôle** : c'est un **cloisonnement par site piloté par l'utilisateur** (décision Matthieu, 11/06). Tout user voit par défaut les prestataires de **son site courant** ; les profils qui doivent voir **tous les sites** (Admin, et selon besoin Bureau/Compta/Commerciale) l'obtiennent via la permission `sites.bypass_scope` (Admin l'a par bypass total). Mécanique complète en § 2.13. + +### 2.10 Validation incrémentale par onglet (workflow front-driven, identique M2) + +`Provider` créé en BDD **dès validation du formulaire principal** via `POST /api/providers`. Onglets suivants → **PATCH partiels** avec groupes de sérialisation dédiés : + +- `provider:write:main` — formulaire principal (POST + PATCH) : `companyName`, `categories`, `sites` +- `provider:write:contacts` — onglet Contact (sous-ressource `provider_contact`) +- `provider:write:addresses` — onglet Adresse (sous-ressource `provider_address`) +- `provider:write:accounting` — onglet Comptabilité (security séparée) +- `provider:write:archive` — toggle archive (security `technique.providers.archive`) + +**Pas de groupe `provider:write:information`** (pas d'onglet Information au M3). **Pas de state machine** côté back (pas de `status = draft|active`). + +### 2.11 Normalisation serveur des entrées texte (identique M1/M2) + +`ProviderFieldNormalizer` (miroir `SupplierFieldNormalizer`), service interne appelé par les Processors avant validation : + +```php +final class ProviderFieldNormalizer +{ + public function normalizeCompanyName(?string $v): ?string // mb_strtoupper(trim) + public function normalizePersonName(?string $v): ?string // mb_convert_case TITLE + public function normalizeEmail(?string $v): ?string // mb_strtolower(trim) + public function normalizePhone(?string $v): ?string // preg_replace('/\D+/', '') +} +``` + +Le formatage `XX XX XX XX XX` est fait à l'affichage front. Le back stocke `0612345678` (chiffres seuls). + +### 2.12 Liste : embed catégories + sites + hydratation anti-N+1 (cohérence M1/M2) + +La **liste** `GET /api/providers` **embarque** les `categories[]` (avec `code`/`name`) et les `sites[]` (avec `name`/`postalCode` — pas de `code`), comme M1/M2. + +> **Différence M3 (importante)** : au M2, `sites[]` de la liste était l'**agrégat dédoublonné des adresses** (`Supplier::getSites()`). Au M3, le **prestataire porte directement des sites** (formulaire principal — RG-3.03, M2M `provider_site`). La colonne « Site » de la liste affiche donc **`provider.sites` (relation directe)**, pas un agrégat d'adresses. Plus simple et plus performant. + +Anti-N+1 (le code fera foi) : le `DoctrineProviderRepository` ne fetch-joine PAS les to-many dans la requête de liste (filtres + tri seulement) ; `hydrateListCollections()` remplit `categories` puis `sites` (relation directe) via des requêtes `IN` bornées séparées sur les mêmes instances (identity map), pour éviter le produit cartésien sur les chemins non paginés (export, `?pagination=false`). Le contrat de sérialisation (groupes `category:read` / `site:read` dans le contexte) est posé **une seule fois** sur l'entité. + +### 2.13 Cloisonnement par site — visibilité pilotée par l'utilisateur (DÉCISION M3) + +> **Décision Matthieu (11/06/2026)** : la visibilité des prestataires est **cloisonnée par site, automatiquement, côté back, en fonction de l'utilisateur** — **pas du rôle**. Un user a un (ou des) site(s) (`user_site`, + un `currentSite` actif). Il ne voit que les prestataires **rattachés à son site**. Les profils qui doivent voir tous les sites passent par `sites.bypass_scope` (Admin l'a par bypass total). Le rôle « Usine » n'est qu'un cas particulier de cette règle générale. + +**Réutilisation de l'infra Sites existante** (`docs/modules/site-aware.md`) : `CurrentSiteProvider` (site courant de l'user), permission `sites.bypass_scope` (voit tous les sites — Admin automatique), users ↔ sites via M2M `user_site`. + +**⚠️ Pourquoi PAS `SiteAwareInterface` standard** : le pattern opt-in `SiteAwareInterface` + `SiteScopedQueryExtension` est **mono-site** (`site_id INT NOT NULL`, ManyToOne unique, filtre `x.site = :currentSite`). Or le prestataire est **multi-site** (M2M `provider_site`, ≥ 1 — RG-3.03). Le pattern standard ne s'applique donc pas tel quel. On câble un **filtre de cloisonnement custom multi-site** (cas explicitement renvoyé au module par `site-aware.md § 6.1 / § 6.2`), qui réutilise `CurrentSiteProvider` + `sites.bypass_scope` : + +- **Filtre LISTE** (`ProviderProvider` ou query extension dédiée `ProviderSiteScopeExtension`) : si l'user **n'a pas** `sites.bypass_scope` ET que `CurrentSiteProvider::get()` retourne un site → ne renvoyer que les prestataires dont `provider.sites` **contient** le `currentSite` (jointure `provider_site` + `WHERE site = :currentSite`). Si l'user a `bypass_scope` (Admin, profils consolidation) → aucun filtre (tous sites). Si `currentSite = null` (mode dégradé / module Sites off) → aligné `site-aware.md § 5` (no-op lecture, à documenter). +- **Filtre DÉTAIL** (`Get`) : un user sans `bypass_scope` qui demande un prestataire **hors de son site courant** → **404** (cohérence : ne pas révéler l'existence d'une ligne hors périmètre). +- **Écriture (décision Matthieu, 11/06)** : un user **sans** `bypass_scope` ne peut attacher **que les sites dont il dispose** (ses `user_site`) — sur le formulaire principal (`provider.sites`, RG-3.03) **comme** sur chaque adresse (`provider_address.sites`, RG-3.05). Tout site hors de ses `user_site` dans le payload → **422** sur `sites`. Un user `bypass_scope` (Admin) peut attacher n'importe quel site. Garde porté par le `ProviderProcessor` (POST + PATCH + sous-ressource adresses). +- **Cohérence sous-ressources** (`/providers/{id}/...`) : le détail étant déjà gardé en 404 hors périmètre, les sous-ressources héritent du garde-fou parent (cf. `site-aware.md § 6.1`). + +> **Conséquence RBAC** : la colonne « Consultation » du docx (« Tout » vs « son site uniquement ») se réalise **par `sites.bypass_scope`**, pas par le code de rôle. Décision d'attribution par défaut (à acter au ticket RBAC) : `bypass_scope` aux profils Admin (auto) + Bureau + Compta + Commerciale (ils voient « Tout » d'après le docx) ; **Usine ne l'a pas** → cloisonné à son site. Si MALIO préfère que Bureau/Commerciale soient aussi cloisonnés, il suffit de ne pas leur donner `bypass_scope` — **aucun code à changer** (c'est l'intérêt de piloter par user/permission et non par rôle). + +> **Index** : `idx_provider_site_site` sur `provider_site(site_id)` (déjà prévu § 3.2) sert le filtre `WHERE site = :currentSite`. + +## 3. Modèle de données + +### 3.1 Diagramme + +``` ++----------------------+ +--------------------------+ +-----------------+ +| provider |--n:m-->| provider_category |<--n:m--| category | +| | +--------------------------+ | type=PRESTATAIRE| +| id (PK) | +-----------------+ +| company_name |--n:m-->| provider_site |<--n:m--| site (Sites) | +| is_archived | +--------------------------+ | (RG-3.03) | +| archived_at | +-----------------+ +| deleted_at | +--------------------------+ +| -- Comptabilité -- |--1:n-->| provider_contact | +| siren / account_num | +--------------------------+ +| tva_mode_id | +-----------------+ +| n_tva | +--------------------------+ | tva_mode (M1) | +| payment_delay_id |--1:n-->| provider_address | | payment_* (M1) | +| payment_type_id | +--------------------------+ | bank (M1) | +| bank_id (nullable) | | (PAS de address_type) +-----------------+ ++----------------------+ +--n:m--> site + +--n:m--> provider_contact + +--------------------------+ +--n:m--> category (PRESTATAIRE) + | provider_rib | + +--------------------------+ + label / bic / iban +``` + +**Particularités M3 (différences vs `supplier`)** : +- **PAS d'onglet Information** : aucun champ `description` / `competitors` / `founded_at` / `employees_count` / `revenue_amount` / `director_name` / `profit_amount` / `volume_forecast`. Le `provider` est minimal : nom + comptabilité. +- **`provider.sites` (M2M `provider_site`)** : sélecteur de site **sur le formulaire principal** (RG-3.03, ≥ 1). NOUVEAU vs supplier (qui n'avait des sites que sur l'adresse). +- **`provider_address` simplifiée** : **pas** de `address_type`, **pas** de `bennes`, **pas** de `triage_provider`. Champs : sites[], street, street_complement, postal_code, city, country, categories[], contacts[]. +- Les référentiels comptables (`tva_mode`...) **ne sont pas recréés** — FK vers les tables M1. + +### 3.2 Migration Doctrine — SQL Postgres + +Namespace : **`DoctrineMigrations` (racine `migrations/`)** — fichier `migrations/VersionYYYYMMDDHHMMSS.php` (à dater par le dev). + +> **Même justification qu'au M1/M2** : la migration crée un schéma avec **FK cross-module** (`user`, `category`, `site`, FK vers les référentiels comptables M1). Le namespace modulaire casserait l'ordre (`make db-reset`) — exception racine de la règle ABSOLUE n°11. Le seed du `CategoryType PRESTATAIRE` se fait **en deux endroits** (migration `ON CONFLICT` pour la prod + fixture idempotente en dev/test). + +> **Rappel règle ABSOLUE n°12** : chaque colonne créée DOIT recevoir son `COMMENT ON COLUMN` (FR, ≤ 200 car., sémantique + contrainte/RG). Les 4 colonnes Timestampable/Blamable passent par le helper. Le SQL ci-dessous est *illustratif* (style aligné M1/M2 : `INT GENERATED BY DEFAULT AS IDENTITY`, `TIMESTAMP(0) WITHOUT TIME ZONE`). + +```sql +-- ===================================================================== +-- Seed taxonomie : nouveau type PRESTATAIRE (référentiels comptables = M1, non recréés) +-- ===================================================================== +INSERT INTO category_type (code, label) VALUES ('PRESTATAIRE', 'Prestataire') + ON CONFLICT (code) DO NOTHING; + +-- ===================================================================== +-- Table principale `provider` +-- ===================================================================== +CREATE TABLE provider ( + id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, + -- Formulaire principal + company_name VARCHAR(180) NOT NULL, + -- (PAS d'onglet Information — aucun champ description/competitors/founded/employees/...) + -- Onglet Comptabilité (FK référentiels M1 — partagés) + siren VARCHAR(20), + account_number VARCHAR(40), + tva_mode_id INT REFERENCES tva_mode(id) ON DELETE RESTRICT, + n_tva VARCHAR(40), + payment_delay_id INT REFERENCES payment_delay(id) ON DELETE RESTRICT, + payment_type_id INT REFERENCES payment_type(id) ON DELETE RESTRICT, + bank_id INT REFERENCES bank(id) ON DELETE RESTRICT, + -- Archive (exposé M3) + is_archived BOOLEAN NOT NULL DEFAULT FALSE, + archived_at TIMESTAMP(0) WITHOUT TIME ZONE, + -- Soft delete (préparé, non exposé au M3) + deleted_at TIMESTAMP(0) WITHOUT TIME ZONE, + -- Timestampable + Blamable + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT REFERENCES "user"(id) ON DELETE SET NULL, + updated_by INT REFERENCES "user"(id) ON DELETE SET NULL +); + +CREATE INDEX idx_provider_is_archived ON provider(is_archived); +CREATE INDEX idx_provider_deleted_at ON provider(deleted_at); +CREATE INDEX idx_provider_created_by ON provider(created_by); +CREATE INDEX idx_provider_updated_by ON provider(updated_by); + +-- Unicité métier (partielle : ignore archives + soft-delete) — nom de société uniquement (cf. § 2.6) +CREATE UNIQUE INDEX uq_provider_company_name_active + ON provider (LOWER(company_name)) + WHERE is_archived = FALSE AND deleted_at IS NULL; + +-- ===================================================================== +-- M2M provider ↔ category (catégories de type PRESTATAIRE — RG-3.09) +-- ===================================================================== +CREATE TABLE provider_category ( + provider_id INT NOT NULL REFERENCES provider(id) ON DELETE CASCADE, + category_id INT NOT NULL REFERENCES category(id) ON DELETE RESTRICT, + PRIMARY KEY (provider_id, category_id) +); +CREATE INDEX idx_provider_category_category ON provider_category(category_id); + +-- ===================================================================== +-- M2M provider ↔ site (sélecteur de site du FORMULAIRE PRINCIPAL — RG-3.03) +-- ===================================================================== +CREATE TABLE provider_site ( + provider_id INT NOT NULL REFERENCES provider(id) ON DELETE CASCADE, + site_id INT NOT NULL REFERENCES site(id) ON DELETE RESTRICT, + PRIMARY KEY (provider_id, site_id) +); +CREATE INDEX idx_provider_site_site ON provider_site(site_id); + +-- ===================================================================== +-- Sous-collection : Contacts (1:n) +-- ===================================================================== +CREATE TABLE provider_contact ( + id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, + provider_id INT NOT NULL REFERENCES provider(id) ON DELETE CASCADE, + first_name VARCHAR(120), + last_name VARCHAR(120), + job_title VARCHAR(120), + phone_primary VARCHAR(20), + phone_secondary VARCHAR(20), + email VARCHAR(180), + position INT NOT NULL DEFAULT 0, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT REFERENCES "user"(id) ON DELETE SET NULL, + updated_by INT REFERENCES "user"(id) ON DELETE SET NULL, + -- RG-3.04 : au moins 1 champ rempli (garanti côté Processor ; le CHECK ci-dessous + -- couvre le cas « nom OU prénom » comme garde-fou minimal aligné M2) + CONSTRAINT chk_provider_contact_name + CHECK (first_name IS NOT NULL OR last_name IS NOT NULL OR phone_primary IS NOT NULL OR email IS NOT NULL) +); +CREATE INDEX idx_provider_contact_provider ON provider_contact(provider_id); + +-- ===================================================================== +-- Sous-collection : Adresses (1:n) — PAS de address_type / bennes / triage +-- ===================================================================== +CREATE TABLE provider_address ( + id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, + provider_id INT NOT NULL REFERENCES provider(id) ON DELETE CASCADE, + country VARCHAR(80) NOT NULL DEFAULT 'France', + postal_code VARCHAR(20) NOT NULL, + city VARCHAR(120) NOT NULL, + street VARCHAR(255) NOT NULL, + street_complement VARCHAR(255), + position INT NOT NULL DEFAULT 0, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT REFERENCES "user"(id) ON DELETE SET NULL, + updated_by INT REFERENCES "user"(id) ON DELETE SET NULL +); +CREATE INDEX idx_provider_address_provider ON provider_address(provider_id); + +-- M2M provider_address ↔ site (RG-3.05 : ≥ 1 site) +CREATE TABLE provider_address_site ( + provider_address_id INT NOT NULL REFERENCES provider_address(id) ON DELETE CASCADE, + site_id INT NOT NULL REFERENCES site(id) ON DELETE RESTRICT, + PRIMARY KEY (provider_address_id, site_id) +); + +-- M2M provider_address ↔ provider_contact +CREATE TABLE provider_address_contact ( + provider_address_id INT NOT NULL REFERENCES provider_address(id) ON DELETE CASCADE, + provider_contact_id INT NOT NULL REFERENCES provider_contact(id) ON DELETE CASCADE, + PRIMARY KEY (provider_address_id, provider_contact_id) +); + +-- M2M provider_address ↔ category (catégorie d'adresse, type PRESTATAIRE — RG-3.09) +CREATE TABLE provider_address_category ( + provider_address_id INT NOT NULL REFERENCES provider_address(id) ON DELETE CASCADE, + category_id INT NOT NULL REFERENCES category(id) ON DELETE RESTRICT, + PRIMARY KEY (provider_address_id, category_id) +); + +-- ===================================================================== +-- Sous-collection : RIB (1:n) +-- ===================================================================== +CREATE TABLE provider_rib ( + id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, + provider_id INT NOT NULL REFERENCES provider(id) ON DELETE CASCADE, + label VARCHAR(120) NOT NULL, + bic VARCHAR(20) NOT NULL, + iban VARCHAR(34) NOT NULL, + position INT NOT NULL DEFAULT 0, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT REFERENCES "user"(id) ON DELETE SET NULL, + updated_by INT REFERENCES "user"(id) ON DELETE SET NULL +); +CREATE INDEX idx_provider_rib_provider ON provider_rib(provider_id); +``` + +### 3.2.bis Commentaires SQL obligatoires (échantillon) + +```php +$this->addSql("COMMENT ON TABLE provider IS 'Répertoire prestataires (M3 Technique) — entités archivables.'"); +$this->addSql("COMMENT ON COLUMN provider.company_name IS 'Raison sociale du prestataire — stockée en MAJUSCULES. Unique parmi non-archivés/non-supprimés (RG-3.10).'"); +$this->addSql("COMMENT ON COLUMN provider.payment_type_id IS 'Type de règlement — FK -> payment_type.id (référentiel partagé M1), ON DELETE RESTRICT. Pilote RG-3.07 (Banque) et RG-3.08 (RIB).'"); +$this->addSql("COMMENT ON COLUMN provider.bank_id IS 'Banque — FK -> bank.id (M1). Obligatoire ssi payment_type=VIREMENT (RG-3.07), null sinon.'"); +$this->addSql("COMMENT ON COLUMN provider.siren IS 'SIREN du prestataire (9 chiffres). Non unique (cf. RG-3.10). Saisi à l''onglet Comptabilité.'"); +// provider_site (M2M) : commenter via COMMENT ON TABLE +$this->addSql("COMMENT ON TABLE provider_site IS 'Sites rattachés au prestataire (sélecteur du formulaire principal — RG-3.03, ≥ 1).'"); +$this->addSql("COMMENT ON COLUMN provider_address.postal_code IS 'Code postal — déclenche l''autocomplétion ville via l''API BAN (RG-3.06).'"); +// + COMMENT ON COLUMN sur TOUTES les autres colonnes métier (cf. règle n°12) +$this->addStandardTimestampableBlamableComments($schema, 'provider'); +$this->addStandardTimestampableBlamableComments($schema, 'provider_contact'); +$this->addStandardTimestampableBlamableComments($schema, 'provider_address'); +$this->addStandardTimestampableBlamableComments($schema, 'provider_rib'); +``` + +### 3.3 Entité `Provider` — squelette (extrait) + +Miroir de `Supplier` (cf. [`../M2-suppliers/spec-back.md § 3.3`](../M2-suppliers/spec-back.md)), **amputé de l'onglet Information** et **augmenté de `sites` (relation directe)**. + +```php + ['provider:read', 'category:read', 'site:read', 'default:read']], + provider: ProviderProvider::class, + ), + new Get( + security: "is_granted('technique.providers.view')", + // Détail embarque sous-collections (contacts, addresses, ribs) + relations imbriquées. + // provider:read:accounting AJOUTÉ dynamiquement par le ReadGroupContextBuilder si accounting.view. + normalizationContext: ['groups' => [ + 'provider:read', 'provider:item:read', + 'category:read', 'site:read', 'default:read', + ]], + provider: ProviderProvider::class, + ), + new Post( + security: "is_granted('technique.providers.manage')", + normalizationContext: ['groups' => ['provider:read', 'default:read']], + denormalizationContext: ['groups' => ['provider:write:main']], + processor: ProviderProcessor::class, + ), + new Patch( + // Security élargie : manage OU accounting.manage (Compta édite la compta sans manage global). + security: "is_granted('technique.providers.manage') or is_granted('technique.providers.accounting.manage')", + normalizationContext: ['groups' => ['provider:read', 'default:read']], + denormalizationContext: ['groups' => [ + 'provider:write:main', 'provider:write:accounting', 'provider:write:archive', + ]], + provider: ProviderProvider::class, + processor: ProviderProcessor::class, + ), + // Pas de Delete au M3 (HP M4). Archivage via PATCH { isArchived: true }. + ], +)] +#[ORM\Entity(repositoryClass: DoctrineProviderRepository::class)] +#[ORM\Table(name: 'provider')] +#[Auditable] +class Provider implements TimestampableInterface, BlamableInterface +{ + use TimestampableBlamableTrait; + + #[ORM\Id, ORM\GeneratedValue, ORM\Column] + #[Groups(['provider:read'])] + private ?int $id = null; + + #[ORM\Column(length: 180)] + #[Assert\NotBlank(message: 'Le nom du prestataire est obligatoire.', normalizer: 'trim')] + #[Assert\Length(min: 2, max: 180, normalizer: 'trim')] + #[Groups(['provider:read', 'provider:write:main'])] + private ?string $companyName = null; + + /** @var Collection Catégories de type PRESTATAIRE (RG-3.09) */ + #[ORM\ManyToMany(targetEntity: Category::class)] + #[ORM\JoinTable(name: 'provider_category')] + #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')] + #[Groups(['provider:read', 'provider:write:main'])] + private Collection $categories; + + /** @var Collection Sites du prestataire — sélecteur du formulaire principal (RG-3.03) */ + #[ORM\ManyToMany(targetEntity: Site::class)] + #[ORM\JoinTable(name: 'provider_site')] + #[Assert\Count(min: 1, minMessage: 'Au moins un site est obligatoire.')] + #[Groups(['provider:read', 'provider:write:main'])] + private Collection $sites; + + // === Onglet Comptabilité (lecture/écriture conditionnées par permission — cf. M2) === + #[ORM\Column(length: 20, nullable: true)] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $siren = null; + + #[ORM\Column(length: 40, nullable: true)] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $accountNumber = null; + + #[ORM\ManyToOne(targetEntity: TvaMode::class)] + #[ORM\JoinColumn(name: 'tva_mode_id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?TvaMode $tvaMode = null; + + #[ORM\Column(length: 40, nullable: true)] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $nTva = null; + + #[ORM\ManyToOne(targetEntity: PaymentDelay::class)] + #[ORM\JoinColumn(name: 'payment_delay_id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?PaymentDelay $paymentDelay = null; + + #[ORM\ManyToOne(targetEntity: PaymentType::class)] + #[ORM\JoinColumn(name: 'payment_type_id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?PaymentType $paymentType = null; + + #[ORM\ManyToOne(targetEntity: Bank::class)] + #[ORM\JoinColumn(name: 'bank_id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?Bank $bank = null; + + // === Sous-collections — EMBARQUÉES dans le DÉTAIL (RETEX M1 §2) === + /** @var Collection */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + #[Groups(['provider:item:read'])] + private Collection $contacts; + + /** @var Collection */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + #[Groups(['provider:item:read'])] + private Collection $addresses; + + /** @var Collection RIB embarqués dans le groupe COMPTA (gated par le Provider) */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderRib::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + #[Groups(['provider:read:accounting'])] + private Collection $ribs; + + // === Archive / Soft delete === + #[ORM\Column(name: 'is_archived', options: ['default' => false])] + private bool $isArchived = false; + + // ⚠ PIÈGE BOOLÉEN (bug #3 M1) : #[Groups] + #[SerializedName('isArchived')] SUR LE GETTER, + // sinon Symfony strip "is" → attribut "archived" → clé droppée. À tester sur JSON réel. + #[Groups(['provider:read', 'provider:write:archive'])] + #[SerializedName('isArchived')] + public function isArchived(): bool + { + return $this->isArchived; + } + // ... archivedAt, getters/setters, __construct (ArrayCollection) ... +} +``` + +### 3.4 Squelettes des autres entités + +Même pattern que les jumelles `Supplier*` (`#[Auditable]`, `TimestampableBlamableTrait`, FK `provider_id`). **Chaque propriété affichée porte un read-group** (RETEX M1 §1 maillon (a)) : + +**`ProviderContact`** — propriétés dans `['provider:item:read', 'provider:write:contacts']` : +`firstName`, `lastName`, `jobTitle`, `phonePrimary`, `phoneSecondary`, `email`, `id`. Embed sous `provider.contacts` au détail ; éditables via la sous-ressource. **Max 2 téléphones** (`phonePrimary` + `phoneSecondary`). + +**`ProviderAddress`** — propriétés dans `['provider:item:read', 'provider:write:addresses']` : +`country`, `postalCode`, `city`, `street`, `streetComplement`, `id`. **PAS** de `addressType` / `bennes` / `triageProvider`. Relations imbriquées (maillon (c) — read-groups dans le contexte du `Get` racine) : +- M2M `sites` → `#[Groups(['provider:item:read'])]` ; `Site` expose `id`/`name`/`postalCode`/`city`/`color` en `site:read` (**pas de `code`**) (`Assert\Count(min:1)` — RG-3.05). +- M2M `contacts` → `#[Groups(['provider:item:read'])]` ; embarque des `ProviderContact`. +- M2M `categories` → `#[Groups(['provider:item:read'])]` ; `Category` (id/code/name, type PRESTATAIRE — RG-3.09). + +**`ProviderRib`** — propriétés dans `['provider:read:accounting', 'provider:write:accounting']` : +`label`, `bic`, `iban`, `id`. Embed sous `provider.ribs` **uniquement** si l'user a `accounting.view`. Aucun `#[AuditIgnore]` sur `iban`/`bic`. + +> ⚠ `Site` / `Category` / référentiels comptables appartiennent à d'autres modules — on consomme leurs read-groups (`site:read`, `category:read`, `provider:read:accounting` pour les réfs compta), **pas de logique inter-module** (§ 2.1). + +## 4. API REST (API Platform) + +### 4.0 Contrat de sérialisation (RETEX M1 — section critique) + +> **Leçon M1/M2** : ~80 % des frictions venaient du contrat de sérialisation. Pour **chaque champ affiché** (liste OU détail), les **3 maillons** doivent être prouvés : (a) groupe sur la propriété, (b) groupe dans le `normalizationContext` de l'opération, (c) read-group de l'entité imbriquée présent dans le contexte parent. + +**Contexte par opération** : + +| Opération | `normalizationContext` (groupes) | +|---|---| +| `GetCollection` (liste) | `provider:read` + `category:read` + `site:read` + `default:read` | +| `Get` (détail) | `provider:read` + `provider:item:read` + `provider:read:accounting`¹ + `category:read` + `site:read` + `default:read` | + +¹ `provider:read:accounting` retiré par le `ProviderProvider` / `ProviderReadGroupContextBuilder` si l'user n'a pas `technique.providers.accounting.view`. + +**LISTE — champ datatable → maillons** : + +| Champ affiché | Propriété (a) | Dans contexte liste (b) | Imbriqué (c) | +|---|---|---|---| +| Nom | `companyName` ∈ `provider:read` | ✅ | — | +| Catégories | `categories` ∈ `provider:read` (embed) | ✅ | `category:read` ✅ (code/**name**) | +| Site | `sites` ∈ `provider:read` (embed, relation **directe** — RG-3.03) | ✅ | `site:read` ✅ (**name**/postalCode, pas de code) | +| Dernière activité | `updatedAt` ∈ `provider:read` | ✅ | — | + +**DÉTAIL — champ → maillons** : + +| Bloc / champ | Propriété (a) | Dans contexte détail (b) | Imbriqué (c) | +|---|---|---|---| +| Scalaires principaux | `provider:read` | ✅ | — | +| `categories[]` (id/code/name) | `categories` ∈ `provider:read` | ✅ | `category:read` ✅ | +| `sites[]` (formulaire principal) | `sites` ∈ `provider:read` | ✅ | `site:read` ✅ | +| `contacts[]` (5 champs) | `contacts` ∈ `provider:item:read` | ✅ | propriétés `ProviderContact` ∈ `provider:item:read` ✅ | +| `addresses[]` (scalaires) | `addresses` ∈ `provider:item:read` | ✅ | propriétés `ProviderAddress` ∈ `provider:item:read` ✅ | +| `addresses[].sites[]` | `sites` ∈ `provider:item:read` | ✅ | `site:read` ✅ | +| `addresses[].categories[]` | `categories` ∈ `provider:item:read` | ✅ | `category:read` ✅ | +| `addresses[].contacts[]` | `contacts` ∈ `provider:item:read` | ✅ | propriétés `ProviderContact` ∈ `provider:item:read` ✅ | +| Scalaires Comptabilité | `provider:read:accounting` | ✅ (gated) | réfs (`tvaMode`…) id+label ∈ `provider:read:accounting` | +| `ribs[]` (label/bic/iban) | `ribs` ∈ `provider:read:accounting` | ✅ (gated) | — | + +### 4.0.bis Réponses JSON de référence (DoD — à CAPTURER sur l'API réelle) + +> **Definition of Done** (miroir ERP-92 du M2) : avant de démarrer les écrans front, **capturer les réponses RÉELLES** via un test PHPUnit (`ProviderSerializationContractTest`, prestataire complet seedé) et les coller ici. Toute donnée affichée par le front DOIT apparaître dans ce JSON. **Ne jamais déclarer un champ « embarqué » sans l'avoir vu dans un JSON réel** (règle anti-régression M2). +> +> **2 pièges hérités M1/M2 à re-tester sur le M3** : +> 1. Réfs comptables (`tvaMode`/`paymentDelay`/`paymentType`/`bank`) : doivent sortir en **objet `{id, code, label}`**, pas en IRI nu → vérifier que les entités partagées portent bien le groupe `provider:read:accounting` (sinon les annoter, comme le fix ERP-92 l'a fait pour `supplier:read:accounting`). +> 2. Gating compta par **omission de clé** : pour un user sans `accounting.view`, les clés `siren`/`tvaMode`/`ribs`/… sont **absentes** (pas `null`). + +`GET /api/providers` (liste, ADMIN — un membre, forme attendue) : +```json +{ + "@context": "/api/contexts/Provider", + "@id": "/api/providers", + "@type": "Collection", + "totalItems": 1, + "member": [ + { + "@id": "/api/providers/1", "@type": "Provider", "id": 1, + "companyName": "MAINTENANCE PRO SAS", + "categories": [ + {"@type": "Category", "@id": "/api/categories/300", "id": 300, "name": "Maintenance industrielle", "code": "MAINTENANCE", + "categoryType": {"@id": "/api/category_types/3", "@type": "CategoryType", "id": 3, "code": "PRESTATAIRE", "label": "Prestataire"}} + ], + "sites": [ + {"@type": "Site", "@id": "/api/sites/87", "id": 87, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"} + ], + "siren": "987654321", "accountNumber": "P0001", + "tvaMode": {"@id": "/api/tva_modes/30", "@type": "TvaMode", "id": 30, "code": "FRANCE_VENTES", "label": "France (ventes)"}, + "paymentType": {"@id": "/api/payment_types/14", "@type": "PaymentType", "id": 14, "code": "LCR", "label": "LCR"}, + "ribs": [ + {"@id": "/api/provider_ribs/1", "@type": "ProviderRib", "id": 1, "label": "Compte principal", "bic": "BNPAFRPPXXX", "iban": "FR1420041010050500013M02606"} + ], + "updatedAt": "2026-06-11T10:00:00+02:00", + "isArchived": false + } + ], + "view": {"@id": "/api/providers", "@type": "PartialCollectionView"} +} +``` + +> Les prestataires archivés sont **exclus** du `totalItems` (RG-3.16). Pour la **Commerciale** (sans `accounting.view`), `siren`/`tvaMode`/`paymentType`/`ribs`… **disparaissent** de chaque membre. + +`GET /api/providers/{id}` (détail — user avec `accounting.view`, forme attendue) : +```json +{ + "@id": "/api/providers/1", "@type": "Provider", "id": 1, + "companyName": "MAINTENANCE PRO SAS", + "categories": [{"@type": "Category", "@id": "/api/categories/300", "id": 300, "name": "Maintenance industrielle", "code": "MAINTENANCE"}], + "sites": [{"@type": "Site", "@id": "/api/sites/87", "id": 87, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"}], + "siren": "987654321", "accountNumber": "P0001", + "tvaMode": {"@id": "/api/tva_modes/30", "@type": "TvaMode", "id": 30, "code": "FRANCE_VENTES", "label": "France (ventes)"}, + "nTva": "FR00987654321", + "paymentDelay": {"@id": "/api/payment_delays/11", "@type": "PaymentDelay", "id": 11, "code": "J30", "label": "30 jours"}, + "paymentType": {"@id": "/api/payment_types/14", "@type": "PaymentType", "id": 14, "code": "LCR", "label": "LCR"}, + "contacts": [ + {"@id": "/api/provider_contacts/1", "@type": "ProviderContact", "id": 1, "firstName": "Marie", "lastName": "Martin", "jobTitle": "Responsable", "phonePrimary": "0612345678", "email": "marie.martin@seed.test"} + ], + "addresses": [ + {"@id": "/api/provider_addresses/1", "@type": "ProviderAddress", "id": 1, "country": "France", "postalCode": "86000", "city": "Poitiers", "street": "12 rue des Acacias", + "sites": [{"@type": "Site", "@id": "/api/sites/87", "id": 87, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"}], + "contacts": [{"@id": "/api/provider_contacts/1", "@type": "ProviderContact", "id": 1, "firstName": "Marie", "lastName": "Martin"}], + "categories": [{"@type": "Category", "@id": "/api/categories/300", "id": 300, "name": "Maintenance industrielle", "code": "MAINTENANCE"}]} + ], + "ribs": [{"@id": "/api/provider_ribs/1", "@type": "ProviderRib", "id": 1, "label": "Compte principal", "bic": "BNPAFRPPXXX", "iban": "FR1420041010050500013M02606"}], + "isArchived": false +} +``` + +> Pour un user **sans** `accounting.view` (ex. Commerciale) : les clés `siren`, `accountNumber`, `tvaMode`, `nTva`, `paymentDelay`, `paymentType`, `bank`, `ribs` **sont absentes** (gating par omission — à confirmer par test). + +### 4.1 `GET /api/providers` — Liste + +- **Security** : `is_granted('technique.providers.view')` +- **Query params** (alimentent le panneau « Filtrer ») : + - `includeArchived=true|false` (default `false`) + - `categoryCode=` (filtre les prestataires ayant ≥ 1 `Category` de ce code ; répétable) + - `siteId=` (filtre via la relation **directe** `provider.sites` ; répétable) — *NB : au M3 le site est porté par le prestataire, le filtre joint `provider_site` (pas les adresses).* + - `search=` (fuzzy sur `companyName` + contacts liés `provider_contact` (firstName / lastName / email) via LEFT JOIN groupé par `provider.id`) +- **Tri par défaut** : `companyName ASC` +- **Cloisonnement par site (§ 2.13)** : si l'user **n'a pas** `sites.bypass_scope`, la liste est filtrée sur les prestataires dont `provider.sites` contient le `currentSite` (RG-3.17). Transparent pour le client (pas de query param). +- **Pagination** : standard Starseed (règle ABSOLUE n°13) — Hydra, 10/page, `?pagination=false` pour les selects. `ProviderProvider` branché sur `ApiPlatform\Doctrine\Orm\Paginator`. ⚠️ Le filtre de cloisonnement s'applique **avant** la pagination (le `totalItems` reflète le périmètre de l'user). +- **Anti N+1 (§ 2.12)** : hydratation des `categories` + `sites` via requêtes `IN` bornées séparées (pas de fetch-join combiné). +- **Codes** : `200` / `401` / `403` + +### 4.2 `GET /api/providers/{id}` — Détail + +- **Security** : `is_granted('technique.providers.view')` +- **Comportement** : prestataire + contacts + adresses + RIBs. Champs `provider:read:accounting` inclus seulement si `technique.providers.accounting.view`. +- **Cloisonnement par site (§ 2.13)** : un user sans `sites.bypass_scope` qui demande un prestataire **hors de son site courant** → **404** (ne pas révéler l'existence hors périmètre — RG-3.17). +- **Codes** : `200` / `404` / `401` / `403` + +### 4.3 `POST /api/providers` — Création (formulaire principal) + +- **Security** : `is_granted('technique.providers.manage')` +- **Body** (groupe `provider:write:main`) : +```json +{ + "companyName": "MAINTENANCE PRO SAS", + "categories": ["/api/categories/300"], + "sites": ["/api/sites/87"] +} +``` +- **Réponse 201** : le prestataire créé avec son `id`. Le front enchaîne les PATCH par onglet. +- **Codes** : + - `201` / `400` / `401` / `403` + - `409 Conflict` si doublon de nom (`companyName` — RG-3.10). SIREN/email non uniques. + - `422` : catégories vides (RG-3.09) ; sites vides (RG-3.03) ; catégorie hors type PRESTATAIRE (RG-3.09). + +### 4.4 `PATCH /api/providers/{id}` — Modification + +- **Security base** : `is_granted('technique.providers.manage')` +- **Security additionnelle** (dans le `ProviderProcessor`) : + - payload contenant un champ `provider:write:accounting` → exige `technique.providers.accounting.manage` + - payload contenant `isArchived` → exige `technique.providers.archive` + - **mode strict** (RG-3.15) : payload mélangeant des groupes hors permissions → 403 sur tout le payload. +- **Body** : merge-patch+json, champs modifiés uniquement. +- **Codes** : `200` / `400` / `401` / `403` / `404` / `409` / `422` + +### 4.5 Sous-ressources + +**Contacts** : `POST /api/providers/{id}/contacts`, `PATCH /api/provider_contacts/{id}`, `DELETE /api/provider_contacts/{id}`. +- **Security** : `is_granted('technique.providers.manage')` +- **RG-3.12** : au moins 1 bloc Contact valide pour finaliser l'onglet côté front. Côté back, la collection peut rester vide (pas de state machine). + +**Adresses** : `POST /api/providers/{id}/addresses`, `PATCH /api/provider_addresses/{id}`, `DELETE /api/provider_addresses/{id}`. +- **Security** : `is_granted('technique.providers.manage')` +- Validations : ≥ 1 site (RG-3.05) ; catégories de type PRESTATAIRE uniquement (RG-3.09) ; `postalCode` matche `^[0-9]{4,5}$` (RG-3.06). + +**RIBs** : `POST /api/providers/{id}/ribs`, `PATCH /api/provider_ribs/{id}`, `DELETE /api/provider_ribs/{id}`. +- **Security** : `is_granted('technique.providers.accounting.manage')` +- **RG-3.08** : si `paymentType.code = LCR`, suppression du dernier RIB → 409. + +### 4.6 `GET /api/providers/export.xlsx` — Export + +- **Security** : `is_granted('technique.providers.view')` +- **Comportement** : XLSX des prestataires **affichés** (mêmes filtres que la liste, non archivés par défaut). +- Colonnes : Nom prestataire, Contact principal (Nom + Prénom), Téléphone principal, Téléphone secondaire, Email, Catégories (CSV), Sites (CSV), SIREN (omis si pas `accounting.view`), Date de création. _(Colonnes contact alimentées depuis le contact principal `provider_contact` de plus petit `position`.)_ +- **Implémentation** : controller custom `ProviderExportController` avec `#[Route(priority: 1)]` (règle ABSOLUE — conflit API Platform `{id}`). Lib : PhpSpreadsheet (déjà présente). +- **Réponse 200** : `Content-Disposition: attachment; filename="repertoire-prestataires-{YYYYMMDD}.xlsx"` + +### 4.7 Référentiels (réutilisés M1/M2 — évolution security) + +`GET /api/tva_modes`, `/api/payment_delays`, `/api/payment_types`, `/api/banks` existent. **Évolution M3** : élargir leur `security` pour autoriser aussi les rôles prestataires, p.ex. `... or is_granted('technique.providers.view')`. Tri `position ASC` puis `label ASC`. Pas d'écriture exposée (HP). + +`GET /api/categories?typeCode=PRESTATAIRE` alimente les multi-selects Catégorie (prestataire + adresse). ✅ **Le filtre `?typeCode=` existe** (créé au M2) — il suffit de **seeder le type `PRESTATAIRE`** + ses catégories. **À vérifier** que le filtre fonctionne pour ce nouveau type (DoD). + +## 5. Autorisation + +### 5.1 Déclaration des permissions + +Créer `TechniqueModule::permissions()` : + +```php +['code' => 'technique.providers.view', 'label' => 'Voir les prestataires'], +['code' => 'technique.providers.manage', 'label' => 'Créer / modifier les prestataires (hors onglet Comptabilité)'], +['code' => 'technique.providers.accounting.view', 'label' => 'Voir l\'onglet Comptabilité d\'un prestataire'], +['code' => 'technique.providers.accounting.manage', 'label' => 'Modifier l\'onglet Comptabilité d\'un prestataire'], +['code' => 'technique.providers.archive', 'label' => 'Archiver / restaurer un prestataire'], +``` + +Synchronisation : `php bin/console app:sync-permissions`. + +### 5.2 Mapping rôles MALIO ↔ permissions + +Cf. § 2.9 (matrice détaillée — identique à la matrice M2 transposée sur `technique.providers`) + § 2.13 (cloisonnement par site via `sites.bypass_scope`). **Attribution `sites.bypass_scope` par défaut** : Admin (auto) + Bureau + Compta + Commerciale ; **Usine non** (cloisonnée à son site). + +### 5.3 Synchronisation RBAC (3 sources OBLIGATOIRES — règle ABSOLUE Starseed n°8) + +1. **`config/sidebar.php`** — **nouvelle section « Technique »** + item : +```php +[ + 'key' => 'technique', + 'label' => 'sidebar.technique.section', + 'items' => [ + [ + 'label' => 'sidebar.technique.providers', + 'to' => '/providers', + 'icon' => 'mdi:account-wrench-outline', + 'module' => 'technique', + 'permission' => 'technique.providers.view', + ], + ], +], +``` + +2. **`frontend/tests/e2e/_fixtures/personas.ts`** — étendre les personas existants : + - Admin : `view` + `manage` + `accounting.view` + `accounting.manage` + `archive` + - Bureau : `view` + `manage` + - Compta : `view` + `accounting.view` + `accounting.manage` + - Commerciale : `view` + `manage` + `sites.bypass_scope` + - Bureau / Compta : + `sites.bypass_scope` (voient tous les sites) + - Usine : `view` **sans** `sites.bypass_scope` → cloisonné à son site (§ 2.13). Persona avec un `currentSite` positionné pour tester le filtre. + +3. **`src/Module/Core/Infrastructure/Console/SeedE2ECommand.php`** — miroir back des mêmes personas. + +> ⚠ Les 3 sources doivent être touchées dans le **même commit** (sinon drift / test cassé). + +### 5.4 Vérification front + +- `usePermissions()` filtre l'item sidebar et masque l'onglet Comptabilité (`technique.providers.accounting.view`). +- Bouton « Archiver » visible si `technique.providers.archive` (Admin seul). + +## 6. Audit & dates + +- `Provider`, `ProviderContact`, `ProviderAddress`, `ProviderRib` : `#[Auditable]`, tous champs audités (y compris `iban`/`bic`). +- Audit M2M automatique sur `provider.categories` et `provider.sites`. +- Timestampable + Blamable : pattern Shared standard (§ 2.8). +- Libellés i18n `audit.entity.technique_*` (§ 2.7). + +## 7. Règles de gestion (RG) + +> Les RG-3.03 → RG-3.08 reprennent le docx source. RG-3.01 / RG-3.02 sont **supprimées** (refonte-contact). Les RG-3.09 → RG-3.16 sont des **précisions back** (miroir M2) explicitement marquées. + +### Formulaire principal + +- ~~**RG-3.01**~~ _(SUPPRIMÉE — refonte-contact, 11/06)_ : le contact principal inline (Nom OU Prénom) est retiré du formulaire principal. Garantie « au moins un contact nommé » portée par **RG-3.04** + **RG-3.12** sur `ProviderContact`. +- ~~**RG-3.02**~~ _(SUPPRIMÉE du formulaire principal — refonte-contact)_ : plus de téléphones inline sur le formulaire principal. Le « maximum 2 téléphones » reste applicable aux blocs `ProviderContact` (`phonePrimary` + `phoneSecondary`). +- **RG-3.03** : Au moins un des 3 sites (86 / 17 / 82) doit être sélectionné sur le **formulaire principal** pour valider la création. `Assert\Count(min: 1)` sur `provider.sites` (M2M `provider_site`). **Spécificité M3** (le fournisseur n'avait pas de site sur le formulaire principal). **Écriture cloisonnée (§ 2.13)** : un user sans `sites.bypass_scope` ne peut choisir que des sites de ses `user_site` (sinon 422). + +### Onglet Contact + +- **RG-3.04** : Un bloc Contact est valide dès qu'**au moins 1 champ** est rempli (Nom, Prénom, Fonction, Téléphone ou Email). CHECK BDD `chk_provider_contact_name` (garde-fou minimal). Côté UI, le bouton « + Nouveau contact » est bloqué tant que le bloc en cours n'a aucun champ rempli. + +### Onglet Adresse + +- **RG-3.05** : Au moins un des 3 sites (86 / 17 / 82) doit être sélectionné sur **chaque adresse**. `Assert\Count(min: 1)` sur `providerAddress.sites` (M2M `provider_address_site`). +- **RG-3.06** : `city` préremplie depuis `postalCode` via l'API **BAN** (api-adresse.data.gouv.fr), appel **direct front** via `useAddressAutocomplete()` (réutilisé M1/M2). Si plusieurs villes correspondent → choix dans le select. Cas dégradé (API down) : Ville en texte libre + toast. Validation serveur : `postalCode` matche `^[0-9]{4,5}$` ; pas de contrôle strict de cohérence CP/Ville. + +### Onglet Comptabilité + +- **RG-3.07** : Le champ `bank` est visible et obligatoire **uniquement** si `paymentType.code = 'VIREMENT'` (options SG / CIC / CA). Validation server-side dans le `ProviderProcessor` : `payment_type = VIREMENT` et `bank IS NULL` → 422. +- **RG-3.08** : Les champs RIB (`label`, `bic`, `iban`) sont obligatoires si `paymentType.code = 'LCR'` : + - `paymentType = LCR` ET `provider.ribs.count() = 0` → 422 « Au moins un RIB est obligatoire pour le type LCR ». + - DELETE du dernier RIB d'un prestataire en LCR → 409. + - Autres types : RIBs optionnels (0..n). + +### Précisions back (miroir M2) + +- **RG-3.09** _(précision back)_ : les `Category` posées sur `provider.categories` ET sur `provider_address.categories` doivent être de **type `PRESTATAIRE`**. Toute catégorie d'un autre type → **422** (`categories: "Type de catégorie non autorisé (PRESTATAIRE attendu)."`). Front : multi-selects alimentés par `GET /api/categories?typeCode=PRESTATAIRE`. +- **RG-3.10** _(précision back)_ : `companyName` unique (case-insensitive) parmi les prestataires non archivés ET non soft-deletés (index partiel `uq_provider_company_name_active`). Doublon → 409 « Un prestataire nommé "{companyName}" existe déjà. » SIREN et email **non** uniques (§ 2.6). +- **RG-3.11** _(normalisation serveur)_ : `companyName` **UPPERCASE** ; `firstName`/`lastName` (sur `ProviderContact`) **Capitalize** ; téléphones **chiffres uniquement** ; `email` **lowercase**. Formatage `XX XX XX XX XX` à l'affichage front. +- **RG-3.12** _(front-driven)_ : au moins 1 bloc Contact valide pour finaliser l'onglet (cf. RG-3.04). Pas de test back. +- **RG-3.13** _(archivage)_ : PATCH `{ "isArchived": true }` exige `technique.providers.archive` (**Admin seul**). Pose `isArchived = true` + `archivedAt = now()`. Aucun autre champ dans la même requête. +- **RG-3.14** _(restauration)_ : PATCH `{ "isArchived": false }` exige la même permission. Pose `isArchived = false` + `archivedAt = null`. Conflit d'unicité (un autre prestataire actif a pris le nom) → 409. +- **RG-3.15** _(PATCH mix de groupes, mode strict)_ : un PATCH mélangeant plusieurs groupes alors que l'user n'a pas toutes les permissions → **403 sur tout le payload** (pas de filtrage silencieux). Le front ne doit jamais envoyer de champ hors-permission. +- **RG-3.16** _(liste / tri)_ : `GET /api/providers` exclut par défaut archivés (`is_archived = TRUE`) + soft-deletés (`deleted_at IS NOT NULL`). `?includeArchived=true` inclut les archivés (pas les soft-deletés). Tri par défaut `companyName ASC`. +- **RG-3.17** _(cloisonnement par site — § 2.13)_ : un user **sans** `sites.bypass_scope` ne voit (liste + détail) que les prestataires dont `provider.sites` contient son `currentSite`. Liste : filtrée avant pagination (`totalItems` = périmètre user). Détail hors périmètre → **404**. Users `bypass_scope` (Admin auto) → tous sites. Cloisonnement **piloté par l'utilisateur, pas par le rôle**. + +## 8. Tests à automatiser + +### 8.1 Cas à couvrir (back — PHPUnit) + +- [ ] **RG-3.03** : POST prestataire sans site → 422 ; avec ≥ 1 site → 201 +- [ ] **RG-3.04** : POST contact totalement vide → 422 (CHECK) ; 1 champ rempli → 200 +- [ ] **RG-3.05** : POST adresse sans aucun site → 422 +- [ ] **RG-3.06** : POST adresse `postalCode` invalide (3 chiffres) → 422 ; CP/ville incohérents → 200 (pas de contrôle strict) +- [ ] **RG-3.07** : POST Comptabilité `paymentType=VIREMENT` sans `bank` → 422 ; avec `bank` → 200 +- [ ] **RG-3.08** : POST `paymentType=LCR` sans RIB → 422 ; DELETE du dernier RIB en LCR → 409 +- [ ] **RG-3.09** : POST `categories` avec une `Category` de type ≠ PRESTATAIRE → 422 (sur provider ET sur provider_address) +- [ ] **RG-3.10** : POST `companyName` déjà pris → 409 ; même nom après archivage de l'ancien → 201 ; SIREN/email dupliqués → 201 +- [ ] **RG-3.11** : POST `companyName="maintenance pro"` → persiste `"MAINTENANCE PRO"` ; normalisation `firstName`/`phonePrimary`/`email` testée via un bloc `ProviderContact` +- [ ] **RG-3.13/14** : PATCH isArchived=true par Bureau (sans `archive`) → 403 ; par Admin → 200 + archivedAt rempli ; restauration en conflit de nom → 409 +- [ ] **RG-3.15** : Bureau PATCH `{companyName, siren}` → 403 sur tout le payload (strict) +- [ ] **RG-3.16** : GET liste sans flag → exclut archivés ; `?includeArchived=true` → inclut ; tri `companyName ASC` +- [ ] **RBAC** : Bureau / Commerciale / Compta / Usine sur chaque permission (matrice § 2.9) — 200/403 selon le verbe +- [ ] **🔴 Cloisonnement par site (RG-3.17 / § 2.13)** : user **sans** `bypass_scope`, `currentSite = 86` → la liste ne contient QUE les prestataires rattachés au site 86 (assertion sur `member` + `totalItems`) ; GET détail d'un prestataire site 17 → **404** ; user `bypass_scope` (admin) → voit tous les sites ; **écriture cloisonnée** : POST/PATCH par un user non-bypass avec un site hors de ses `user_site` (formulaire principal OU adresse) → 422 ; avec uniquement ses propres sites → 201/200 +- [ ] **Compta** : GET prestataire retourne les champs accounting ; PATCH accounting → 200 ; PATCH contacts/adresses → 403 ; POST création → 403 +- [ ] **Commerciale** : GET prestataire **sans** les champs accounting ; onglet Comptabilité masqué +- [ ] **🔴 Gating RIB (bug #4 M1)** : GET détail en tant que Commerciale → la clé `ribs` est **ABSENTE** (assertion sur le corps JSON) +- [ ] **🔴 Sérialisation booléen (bug #3 M1)** : GET détail expose bien la clé `isArchived` dans le JSON réel +- [ ] **Embed relations (bugs #1/#2 M1)** : GET **liste ET détail** → `categories[].code` + `.name` présents ; `sites[]` (relation directe) exposent `name` + `postalCode` (objet Site entier, PAS un IRI nu) ; `addresses[].sites[]` au détail +- [ ] **Filtre typeCode** : `GET /api/categories?typeCode=PRESTATAIRE` ne renvoie QUE les catégories de type PRESTATAIRE +- [ ] **Anti N+1 liste (§ 2.12)** : sur `GET /api/providers` avec N prestataires, nombre de requêtes SQL constant +- [ ] **Audit** : POST + PATCH + archive → audit_log `entity_type='Provider'`, `changes` correct ; iban/bic présents dans le diff ; M2M `sites`/`categories` tracés +- [ ] **Pagination** (règle n°13) : enveloppe Hydra (`totalItems` / `view`) ; `?pagination=false` renvoie tout +- [ ] **Migration** : `make db-reset` → schéma OK ; namespace racine ; CategoryType PRESTATAIRE présent APRÈS db-reset (fixture idempotente) ; index partiel `uq_provider_company_name_active` présent ; **toutes les colonnes ont un `COMMENT ON COLUMN`** (`ColumnsHaveSqlCommentTest` vert) +- [ ] **i18n audit** : `audit.entity.technique_provider`… présents (`AuditableEntitiesHaveI18nLabelTest` vert) + +### 8.2 Cas à couvrir (front — Vitest) + +- [ ] `usePaginatedList({url:'/providers'})` : exclusion archivés par défaut, envelope Hydra +- [ ] `useProviderForm()` : workflow par onglet (validation incrémentale, PATCH partiel) — **sans onglet Information** +- [ ] `useAddressAutocomplete()` : réutilisation M1/M2 (nominal + dégradé) — pas de nouveau test si déjà couvert +- [ ] Sélecteur de site formulaire principal (RG-3.03) : ≥ 1 requis +- [ ] `` : `` + « + Ajouter » → `/providers/new` +- [ ] Permissions : Compta accède à `/providers/{id}` mais onglet Comptabilité éditable seul ; Commerciale ne voit pas l'onglet Comptabilité +- [ ] `useFormErrors` : mapping 422 inline par champ (formulaire principal + blocs) + +### 8.3 Tests E2E + +**Non prévus au M3** (règle ABSOLUE n°7). Extension des personas existants pour ajouter les permissions `technique.providers.*` — cf. § 5.3. + +### 8.4 Seed & fixtures démo (RETEX M1 §7 — prévu dès la spec) + +`ProviderFixtures` idempotent couvrant tous les cas des RG : +- Catégories de type PRESTATAIRE seedées (au moins « Maintenance industrielle », « Nettoyage », « Transport »). +- ≥ 1 prestataire **complet** (≥ 1 site sur le formulaire principal, ≥ 1 contact, ≥ 1 adresse multi-sites, comptabilité + RIB). +- 1 prestataire **en LCR avec RIB** (RG-3.08) et 1 **en VIREMENT avec banque** (RG-3.07). +- 1 prestataire **archivé** (vérifier exclusion liste + restauration). +- Réutiliser les comptes de rôles démo (`bureau`, `compta`, `commerciale`, `usine`, `admin`). + +> Idempotence obligatoire (le purger Doctrine vide `category`/`category_type` au `db-reset`). Le `CategoryType PRESTATAIRE` est seedé **en migration ET en fixture**. + +### 8.5 Checklist RETEX (à cocher avant « spec prête ») + +- [x] 3 maillons de sérialisation documentés pour chaque champ liste + détail (§ 4.0) +- [x] Décision embed vs GetCollection explicite et câblée (embed détail + sous-ressources write — § 3.3 / § 3.4 / § 4.5), **pas de POST-only** +- [ ] **Réponses JSON RÉELLES** à capturer (§ 4.0.bis) — gabarit posé, capture à faire au 1er ticket back (DoD avant front) +- [x] Matrice RBAC rôle × onglet + mode strict PATCH (§ 2.9 / RG-3.15) +- [x] Pagination (n°13), COMMENT ON COLUMN (n°12), Timestampable/Blamable, Audit + i18n, routes à plat : rappelés +- [x] Réutilisations M1/M2 identifiées (référentiels compta partagés, taxonomie code/type, filtre `?typeCode=`, `usePaginatedList`, blocs, archive, normalisation, `useAddressAutocomplete`) +- [x] Seed/fixtures démo planifiés (§ 8.4) +- [x] **Décisions tranchées (Matthieu, 11/06)** : module `Technique` (§ 2.1) ✅ ; référentiels comptables « comme supplier » (ORM partagée) ✅ ; cloisonnement par site piloté user via `sites.bypass_scope` (§ 2.13 / RG-3.17) ✅ ; unicité nom seul (§ 2.6) ✅ + +## 9. Hors-périmètre (HP) + +- **HP-M4-2** : **Remontée des référentiels comptables dans `Shared`** (ou module neutre) si isolation stricte souhaitée (cf. § 2.1). _NB : décision M3 = consommation ORM partagée, comme `Supplier` (validée Matthieu, 11/06)._ +- _**(ex-HP-M4-1 — DÉSORMAIS DANS LE PÉRIMÈTRE M3)**_ : le **cloisonnement par site** (visibilité prestataires selon le site de l'utilisateur) est implémenté au M3 — cf. § 2.13 + RG-3.17. Le « bypass multi-sites » passe par `sites.bypass_scope`. +- **HP-M4-3** : **DELETE / soft delete d'un prestataire** (colonne `deleted_at` préparée, non exposée au M3). +- **HP-M4-4** : **CRUD admin des référentiels comptables** (`TvaMode` / `PaymentDelay` / `PaymentType` / `Bank`) — partagés, seed seulement. +- **HP-M4-5** : **CRUD admin de `CategoryType`** (le M3 seed seulement le type PRESTATAIRE). +- **HP-M4-6** : **Onglet Rapports** (front placeholder « À venir » ; aucun modèle ni API back). +- **HP-M4-7** : **Onglet Échanges** (placeholder « À venir »). +- **HP-M4-8** : **Validation IBAN/BIC stricte** (au M3, `Assert\Iban` / `Assert\Bic` standard sur `ProviderRib`). +- **HP-M4-9** : **Validation SIREN stricte** (Luhn) — au M3, `Assert\Length(9)` + `Assert\Regex('/^\d{9}$/')`. +- **HP-M4-10** : **Référencement entrant** (modules futurs ajoutant une FK `provider_id` : interventions, maintenance, etc.). +- **HP-M4-11** : **Export CSV** (XLSX uniquement au M3). +- **HP-M4-12** : **Liaison Prestataire ↔ Fournisseur / Client** (un même tiers multi-rôles). Au M3, entités strictement séparées. + +## 10. Liens & dépendances + +### Liens + +- Spec front : [`./spec-front.md`](./spec-front.md) +- Spec M2 fournisseurs (pattern de référence direct) : [`../M2-suppliers/spec-back.md`](../M2-suppliers/spec-back.md) +- Spec M1 clients : [`../M1-clients/spec-back.md`](../M1-clients/spec-back.md) +- RETEX sérialisation : [`../_RETEX-M1-pour-M2.md`](../_RETEX-M1-pour-M2.md) +- Doc audit-log : [`../../audit-log.md`](../../audit-log.md) +- Site-aware (périmètre Usine) : [`../../modules/site-aware.md`](../../modules/site-aware.md) +- BAN api : `https://adresse.data.gouv.fr/api-doc/adresse` +- Trace fonctionnelle : `M3-reportoire-prestataires.docx` (V0.2) / `M3-reportoire-prestataires-V01.pdf` (V0.1, obsolète) + +### Dépendances amont (déjà en place dans Starseed) + +- Module `Commercial` : référentiels comptables `TvaMode` / `PaymentDelay` / `PaymentType` / `Bank` (**partagés**, relation ORM) +- Module `Catalog` (M0) : `Category` + `CategoryType` + **filtre `?typeCode=`** (créé au M2) (+ seed type PRESTATAIRE au M3) +- Module `Sites` : `Site` (3 sites 86/17/82) — M2M `provider_site` + `provider_address_site` +- Module `Core` : `User`, `Role`, `Permission`, `Audit`, JWT +- `Shared` : `TimestampableBlamableTrait` + `Subscriber` +- API Platform 4 + Doctrine ORM + PostgreSQL 16 + PhpSpreadsheet (export) + +### Specs futures qui dépendent du M3 + +- **M-Interventions / Maintenance** : FK `provider_id`. + +--- + +## 📦 Tickets Lesstime (à découper) + +**TaskGroup Lesstime** : à créer — `M3 — Répertoire prestataires` (projet `ERP / Starseed`, projectId=6). + +Ordre indicatif (back avant front, migration en tête) : +0. **Module `Technique` + Taxonomie PRESTATAIRE** — créer `TechniqueModule` (ID/LABEL/REQUIRED/permissions) + activer dans `config/modules.php` + layer front `modules/technique/` ; seed `CategoryType PRESTATAIRE` (migration `ON CONFLICT` + fixture idempotente) + catégories prestataires ; **vérifier** que le filtre `?typeCode=PRESTATAIRE` fonctionne. Prérequis du multi-select Catégorie. +1. **Migration BDD M3** (tables provider + provider_site + sous-collections + M2M + index partiel + COMMENT ON COLUMN) +2. **Entités + Repositories** (Provider, ProviderContact, ProviderAddress, ProviderRib) + **hydratation liste** (categories, sites — § 2.12) +3. **Provider + Processor** (ProviderProvider paginé, ProviderProcessor — normalisation, archivage, accounting conditionnel, mode strict, gating) + **filtre de cloisonnement par site** (§ 2.13 / RG-3.17 : `ProviderSiteScopeExtension` réutilisant `CurrentSiteProvider` + `sites.bypass_scope` ; liste filtrée, détail 404 hors périmètre) +4. **Sous-ressources** (ProviderContactProcessor, ProviderAddressProcessor, ProviderRibProcessor) +5. **Validators** (contrôle catégorie type PRESTATAIRE, RG-3.07/3.08, ≥1 site formulaire principal RG-3.03) +6. **Export XLSX** (ProviderExportController, priority:1) +7. **RBAC** : `TechniqueModule::permissions()` + sync 3 sources + tests personas +8. **Tests PHPUnit** : matrice RG-3.03 → RG-3.16 (§ 8.1) + capture JSON réel (§ 4.0.bis) +9. **Front : page Répertoire** (`/providers`) + `usePaginatedList` +10. **Front : page Création** (`/providers/new`) + `useProviderForm` (sans onglet Information) +11. **Front : page Consultation** (`/providers/{id}`) + onglets placeholder « À venir » (Rapports / Échanges) +12. **Front : page Modification** (`/providers/{id}/edit`) +13. **i18n + Sidebar** (section `sidebar.technique.section` + `sidebar.technique.providers` + permission, traductions, libellés audit) + +### Actions manuelles dans Lesstime (Matthieu) + +1. Créer le TaskGroup `M3 — Répertoire prestataires` (projet ERP / Starseed, projectId=6). +2. Créer les ~14 tickets ci-dessus (ticket 0 module+taxonomie inclus) avec dépendances séquentielles. +3. Mettre à jour le frontmatter (`lesstime_taskgroup_id`) avec l'id réel. + +### ✅ Décisions tranchées (Matthieu, 11/06/2026) + +1. **Module `Technique`** (§ 2.1) — nouveau module back + section sidebar « Technique ». ✅ +2. **Référentiels comptables** — « comme supplier » : consommation ORM partagée (pas de remontée dans `Shared`). ✅ +3. **Cloisonnement par site** (§ 2.13 / RG-3.17) — visibilité pilotée par l'**utilisateur** (son `currentSite`), automatique côté back ; bypass multi-sites via `sites.bypass_scope` (Admin auto + Bureau/Compta/Commerciale ; **Usine cloisonnée**). Indépendant du rôle. ✅ +4. **Unicité = nom seul** (§ 2.6). ✅ + +5. **Écriture cloisonnée** (§ 2.13 / RG-3.03 / RG-3.05) — un user non-bypass ne peut attacher que **les sites dont il dispose** (`user_site`), formulaire principal ET adresses ; site hors périmètre → 422. ✅ + +### ⚠️ Point de raffinement à confirmer (non bloquant) + +- **Attribution `sites.bypass_scope`** : confirmer la liste des profils « voient tous les sites » (défaut : Admin + Bureau + Compta + Commerciale ; Usine non). diff --git a/docs/specs/M3-prestataires/spec-front.md b/docs/specs/M3-prestataires/spec-front.md new file mode 100644 index 0000000..bc6720b --- /dev/null +++ b/docs/specs/M3-prestataires/spec-front.md @@ -0,0 +1,339 @@ +--- +# === IDENTITÉ === +module: M3 +nom: "Répertoire prestataires" +ecran: repertoire-prestataires +owner_spec: Matthieu +backup_spec: Tristan +version: V0.2 +date_redaction: 2026-06-11 +# Historique : +# V0.2 (2026-06-11) — Restitution Markdown du docx « M3-reportoire-prestataires.docx » (04/06/2026). +# Alignement refonte-contact (comme M1/M2) : le contact principal inline du formulaire principal +# du PDF V0.1 (Nom contact / Prénom contact / Téléphone + / Email) est RETIRÉ — saisie via +# l'onglet Contacts uniquement (décision Matthieu, 11/06 : « oublie le contact inline, comme client »). +# RG-3.01 / RG-3.02 (contact inline + max 2 tél sur le formulaire principal) supprimées en conséquence. +# V0.1 (PDF) — version fonctionnelle plus ancienne, NON retenue (contact inline sur le formulaire principal). + +# === LIENS === +maquette_figma: "https://www.figma.com/design/jRYgT0T9c03VsEbjGhCwwS/Composants---Design-System?node-id=1132-42090&p=f&m=dev" +regles_metier: [RG-3.03, RG-3.04, RG-3.05, RG-3.06, RG-3.07, RG-3.08, RG-3.09, RG-3.10, RG-3.11, RG-3.12, RG-3.13, RG-3.14, RG-3.15, RG-3.16, RG-3.17] +roles: [Admin, Bureau, Compta, Commerciale, Usine] +lien_spec_back: ./spec-back.md + +# === VALIDATION CLIENT === +client_validation_1: + statut: validee + date: 2026-05-22 + version: V0 + valide_par: "Matthieu (CP MALIO)" +client_validation_2: + statut: validee + date: 2026-06-01 + version: V0.1 + valide_par: "Matthieu (CP MALIO)" +client_validation_3: + statut: a_valider + date: 2026-06-04 + version: V0.2 + resume: "Module 3 — Répertoire prestataires. Pôle Technique (nouvelle section sidebar). Datatable + 3 écrans (Ajouter / Consulter / Modifier). Création par onglets : Contact / Adresse / Comptabilité (Rapports, Échanges = placeholders 'À venir'). PAS d'onglet Information. Sélecteur de site aussi sur le formulaire principal." + trace_archivee: "uploads/M3-reportoire-prestataires.docx (V0.2) + M3-reportoire-prestataires-V01.pdf (V0.1, obsolète)" + +# === LIEN LESSTIME === +lesstime_taskgroup_id: 29 # M3 — Répertoire prestataires (projet STARSEED #6) +lesstime_project_id: 6 +statut_global: en_dev +--- + +# Module 3 — Répertoire prestataires (V0.2 front) + +> **Origine** : spec fonctionnelle `M3-reportoire-prestataires.docx` (V0.2 du 04/06/2026 ; historique V0 22/05 → V0.1 01/06). Restitution Markdown pour intégration au workflow MALIO. Le contenu fonctionnel original n'est pas modifié, **sauf** l'alignement refonte-contact (cf. ci-dessous). Toute décision technique (back) vit dans [`spec-back.md`](./spec-back.md). Le M3 réutilise massivement le pattern et les composants posés au [M1 clients](../M1-clients/spec-front.md) et au [M2 fournisseurs](../M2-suppliers/spec-front.md). + +> **⚠️ Alignement refonte-contact (décision Matthieu, 11/06/2026)** : le PDF V0.1 portait un **contact principal inline** sur le formulaire principal (Nom du contact / Prénom du contact / Téléphone + bouton + / Email) avec RG-3.01 (Nom OU Prénom) et RG-3.02 (max 2 téléphones). Ce contact inline est **retiré**, exactement comme l'a fait M1/M2 (refonte-contact). Les coordonnées du contact se saisissent **uniquement dans l'onglet Contacts**. **RG-3.01 et RG-3.02 sont donc supprimées du formulaire principal** ; la garantie « au moins un contact nommé » est portée par RG-3.04 + RG-3.12, et le « maximum 2 téléphones » s'applique aux blocs Contact. + +> **⚠️ Décision d'architecture (à confirmer) — pôle « Technique »** : le docx place le répertoire prestataires dans un **Module « Technique »**. Confirmé par Matthieu (11/06) : c'est bien un **nouveau pôle Technique**, distinct du Commercial. Côté front cela se traduit par une **nouvelle section sidebar « Technique »** (route `/providers`). Côté back, voir [`spec-back.md § 2.1`](./spec-back.md) (nouveau module `Technique`, entités jumelles du fournisseur, référentiels comptables consommés en relation ORM partagée). + +## But + +Lister tous les prestataires de l'organisation et accéder rapidement à leurs fiches : consultation, création, modification, archivage. C'est la **porte d'entrée du pôle Technique**. + +## Accès + +- **Depuis** : menu principal → section **Technique** → entrée « Répertoire prestataires » (route `/providers`). +- **Rôles autorisés** (tableau « Rôles & permissions » du docx) : + +| Rôle | Consultation | Création / Modification | Archivage | +|---|---|---|---| +| **Admin** | ✅ Tout | ✅ Tout | ✅ | +| **Bureau** | ✅ Tout | ✅ Tout sauf onglet Comptabilité | ❌ | +| **Compta** | ✅ Tout | ✅ Onglet Comptabilité uniquement | ❌ | +| **Commerciale** | ✅ Tout sauf Comptabilité | ✅ Tout sauf Comptabilité | ❌ | +| **Usine** | ✅ Son site uniquement | — | ❌ | + +> **Notes** : +> - RBAC transposée sur `technique.providers.*` (cf. [`spec-back.md § 2.9 / § 5`](./spec-back.md)). Compta édite uniquement l'onglet Comptabilité d'un prestataire existant ; Compta ne peut pas **créer** un prestataire. **L'archivage est réservé à Admin**. +> - **Cloisonnement par site (décision 11/06 — DANS LE PÉRIMÈTRE M3)** : « Tout » vs « son site uniquement » n'est **pas porté par le rôle** mais par l'**utilisateur**. Chaque user a un site courant ; **par défaut il ne voit que les prestataires rattachés à son site**. Les profils qui doivent voir tous les sites (Admin, et par défaut Bureau / Compta / Commerciale) ont la permission `sites.bypass_scope` (Admin l'a automatiquement). **Usine** n'a pas le bypass → cloisonnée à son site. Filtrage **automatique côté back** (cf. [`spec-back.md § 2.13`](./spec-back.md)) — aucun filtre à coder côté front. + +## Navigation + +Page d'entrée du pôle **Technique** (route `/providers`). Titre : « **Répertoire prestataires** ». + +- Affichage principal : un **datatable** listant tous les prestataires **actifs** (les archivés sont masqués par défaut — toggle/filtre dédié). +- **Clic sur une ligne** → écran **Consultation prestataire** (page dédiée). +- **Bouton « + Ajouter »** (haut droite) → écran **Ajouter un prestataire**. +- **Bouton « Filtrer »** (haut droite) → panneau de filtres (cf. ci-dessous). +- **Bouton « Exporter »** (haut droite) → télécharge un **XLSX** des prestataires **affichés** (cf. filtres actifs). Format dans [`spec-back.md § 4.6`](./spec-back.md). + +### Panneau de filtres (bouton « Filtrer ») + +Réutilise le pattern M1/M2. Filtres branchés sur les query params de `GET /api/providers` (cf. [`spec-back.md § 4.1`](./spec-back.md)) : + +| Filtre | Composant | Query param back | +|---|---|---| +| **Recherche** (nom entreprise / contact / email) | `` | `?search=` | +| **Catégorie** | `` (multi, type PRESTATAIRE) | `?categoryCode=` | +| **Site** | `` (86 / 17 / 82) | `?siteId=` | +| **Inclure les archivés** | `` | `?includeArchived=true` | + +- À l'application des filtres → `setFilters(...)` de `usePaginatedList` (retombe en **page 1**), qui relance `GET /api/providers`. +- **État 100 % local** (jamais dans l'URL — règle ABSOLUE n°6). + +## Datatable du Répertoire + +Composant : `` branché sur `usePaginatedList({ url: '/providers' })` (règle frontend obligatoire — pagination Hydra, état 100 % local). Colonnes (alignées M2) : + +| Colonne | Source | Tri | +|---|---|---| +| **Nom** | `provider.companyName` | ASC par défaut | +| **Catégories** | `provider.categories[].name` (embarquées en liste — cohérence M1/M2 ; libellé = `name`, pas `label`) | Non | +| **Site** | `provider.sites[].name` (sites du prestataire — cf. note ci-dessous) | Non | +| **Dernière activité** | `provider.updatedAt` (format `JJ-MM-AAAA`) — exposé dans `provider:read` | Oui | + +> **Source de la colonne « Site »** : le M3 porte un sélecteur de site **sur le formulaire principal** (RG-3.03) — donc `provider.sites[]` est une relation **directe** du prestataire (≠ M2 où les sites venaient de l'agrégat des adresses). La colonne liste affiche ces sites directs. Voir [`spec-back.md § 2.12`](./spec-back.md). +> **Clic sur une ligne** → écran Consultation. **Pagination** : standard Starseed 10 / 25 / 50 (défaut 10). Tri serveur `companyName ASC` par défaut. + +## Écran « Ajouter un prestataire » + +Création par **onglets successifs avec validation incrémentale** : pour passer à l'onglet suivant, il faut avoir validé l'onglet en cours. **Une fois un onglet validé, on passe automatiquement au suivant** ; les champs validés passent en lecture seule + bouton « Valider » désactivé (disabled). Cf. [`spec-back.md § 2.10`](./spec-back.md) (PATCH partiels par groupe de sérialisation). + +**Accès** : bouton « + Ajouter » du Répertoire. **Rôles** : Admin, Bureau. + +**Barre d'onglets en création (3 onglets)** : `Contact` · `Adresse` · `Comptabilité`. Les onglets `Rapports` et `Échanges` **n'apparaissent PAS dans le flux de création** — ils ne sont présents qu'en Consultation / Modification (placeholders « À venir »). + +> **Différence majeure avec M2 : PAS d'onglet « Information ».** Le M3 n'a aucun champ Description / Concurrent / Date création / Salariés / CA / Dirigeant / Résultat / Volume. Le formulaire principal est minimal (3 champs). + +> **Règle « placeholder par défaut » (convention MALIO)** : tout onglet ou écran que la spec ne détaille pas explicitement (ici **Rapports** et **Échanges**) est livré en **placeholder « À venir »** (frame vide, navigable, pas de validation ni d'API), à l'identique des autres modules (M1/M2). Aucun champ inventé hors spec. + +### Formulaire principal (pré-onglets) + +1er bloc à remplir. Sans validation, les onglets ne sont pas accessibles. Une fois validé → POST `/api/providers`, puis bascule sur l'onglet Contact ; les champs passent en readonly. + +| Champ | Type composant | Obligatoire | Règle | +|---|---|---|---| +| **Nom du prestataire (Entreprise)** | `` | Oui | RG-3.11 (UPPERCASE serveur) ; RG-3.10 (unicité) | +| **Catégorie** | `` (multi) | Oui | `Category` de **type PRESTATAIRE** via `GET /api/categories?typeCode=PRESTATAIRE` (RG-3.09). Libellé affiché = `category.name`. | +| **Sélecteur de site** | `` (86 / 17 / 82) | Oui | RG-3.03 — ≥ 1 site. Les 3 cases = les 3 `Site` fixes ; libellés « 86/17/82 » = **préfixe du `postalCode`** (86100 / 17400 / 82400), pas un `Site.code` (qui n'existe pas). La sélection stocke des **IDs de Site** (M2M `provider_site`). | + +**Action** : « Valider » (``) → POST `/api/providers` ([`spec-back.md § 4.3`](./spec-back.md)). Succès → onglet « Contact ». + +### Onglet « Contact » + +Saisir un ou plusieurs contacts. Au moins un bloc Contact valide est requis (RG-3.12). **(Refonte-contact : pas de pré-remplissage depuis le formulaire principal ; les coordonnées du contact se saisissent directement ici.)** + +**Bloc Contact** : + +| Champ | Type | Obligatoire | Règle | +|---|---|---|---| +| **Nom** | `` | Conditionnel | RG-3.04 + RG-3.11 (Capitalize) | +| **Prénom** | `` | Conditionnel | RG-3.04 + RG-3.11 (Capitalize) | +| **Fonction** | `` | Non | — | +| **Téléphone** (x1, +1 possible, **max 2**) | `` | Non | RG-3.11 (format) ; max 2 téléphones par contact | +| **Email** | `` type email | Non | RG-3.11 (lowercase) | + +**RG-3.04 / RG-3.12** : un bloc Contact est valide dès qu'au moins 1 champ est rempli ; au moins 1 bloc Contact valide pour finaliser l'onglet — l'onglet Contact ne peut pas être validé vide. + +**Actions** : +- « + Nouveau contact » : ajoute un bloc. **Désactivé tant que le bloc précédent n'a pas au moins 1 champ rempli** (RG-3.04). +- « Supprimer » (icône) : modal de confirmation, puis suppression du bloc. +- « Valider » → PATCH `/api/providers/{id}/contacts`. + +### Onglet « Adresse » + +Saisir une ou plusieurs adresses, rattachées à un ou plusieurs sites (86 / 17 / 82) et à des contacts. + +**Bloc Adresse** : + +| Champ | Type | Obligatoire | Règle | +|---|---|---|---| +| **Sélecteur de site** | `` (86 / 17 / 82) | Oui | RG-3.05 — ≥ 1 site. Stocke des IDs de Site (M2M `provider_address_site`). | +| **Adresse** | `` (saisie assistée) | Oui | RG-3.06 — autocomplete BAN | +| **Adresse complémentaire** | `` | Non | — | +| **Code postal** | `` (saisie assistée) | Oui | RG-3.06 — déclenche autocomplete ville (BAN) | +| **Ville** | `` (saisie assistée) | Oui | RG-3.06 — alimentée par api-adresse.data.gouv.fr suivant le CP ; si plusieurs villes, choix dans le select | +| **Pays** | `` (préremplie « France ») | Oui | — | +| **Catégories** | `` (multi) | Oui | Catégories de type PRESTATAIRE (RG-3.09) | +| **Contact** | `` (multi) | Non | Liste = blocs Contact saisis dans l'onglet Contact | + +> **Différence avec M2** : l'adresse prestataire n'a **PAS** de Type d'adresse (Prospect/Départ/Rendu), **PAS** de Bennes, **PAS** de Prestation de triage. C'est une adresse « simple » (site + adresse postale + catégories + contacts). + +**Actions** : +- « + Nouvelle Adresse » : ajoute un bloc identique au premier. +- « Supprimer » (icône) : modal de confirmation puis suppression. +- « Valider » → PATCH `/api/providers/{id}/addresses`. + +### Onglet « Comptabilité » + +⚠ **Accessible aux rôles avec `technique.providers.accounting.view`** (Admin + Compta). Bureau et Commerciale ne voient pas l'onglet. **Compta peut éditer** cet onglet (`accounting.manage`). Compta ne peut pas créer un prestataire (pas de `manage` global). + +**Champs comptables** : + +| Champ | Type | Obligatoire | Règle | +|---|---|---|---| +| **SIREN** | `` (masque 9 chiffres) | Oui | 9 chiffres. **Pas d'unicité** (cf. [`spec-back.md § 2.6`](./spec-back.md)) | +| **Numéro de compte** | `` | Oui | — | +| **Mode de TVA** | `` | Oui | Liste depuis `/api/tva_modes` (référentiel partagé M1) | +| **N° de TVA** | `` | Oui | — | +| **Délai de règlement** | `` | Oui | Liste depuis `/api/payment_delays` | +| **Type de règlement** | `` | Oui | Liste depuis `/api/payment_types` | +| **Banque** | `` | Conditionnel | RG-3.07 — visible et obligatoire **si** Type de règlement = `VIREMENT`. Liste depuis `/api/banks` (SG / CIC / CA). | + +**Bloc RIB** (0..n, présence obligatoire conditionnée par RG-3.08) : + +| Champ | Type | Obligatoire | Règle | +|---|---|---|---| +| **Libellé** | `` | Oui (si LCR) | RG-3.08 | +| **BIC** | `` | Oui (si LCR) | RG-3.08 | +| **IBAN** | `` | Oui (si LCR) | RG-3.08 | + +**Actions** : +- « + RIB » : ajoute un bloc. +- « Supprimer » (icône) : modal de confirmation. +- « Valider » → PATCH `/api/providers/{id}` (groupe `provider:write:accounting`) + sous-ressource RIBs. + +## Écran « Consultation prestataire » + +Tous les champs en **lecture seule**. La page s'ouvre par défaut sur l'onglet **Contacts**. Layout identique à l'écran Ajouter mais sans bouton « Valider », sans `+` pour ajouter des blocs. + +- **Flèche retour** (gauche) → revient au Répertoire. +- **Bouton « Modifier »** (droite, visible si `technique.providers.manage`) → écran Modification. +- **Bouton « Archiver »** (droite, visible **uniquement Admin** via `technique.providers.archive`) → modal de confirmation, puis PATCH `/api/providers/{id}` `{ "isArchived": true }`. + +> Un prestataire archivé peut être restauré (`isArchived: false`) — bouton « Restaurer » remplace « Archiver » dans la consultation d'un archivé. + +### Onglets affichés en consultation + +`Contacts` · `Adresse` · `Rapports` · `Échanges` · `Comptabilité`. Navigation **libre** entre onglets (pas de séquence forcée). `Rapports` et `Échanges` = placeholders « À venir ». `Comptabilité` selon permission. + +- **Onglet Contacts** : un bloc par contact, 5 champs en lecture seule (Nom / Prénom / Fonction / Téléphone / Email). +- **Onglet Adresse** : un bloc par adresse, en lecture seule (Sélecteur de site / Adresse / Adresse complémentaire / Code postal / Ville / Pays / Catégorie / Contact). +- **Onglet Comptabilité** : bloc principal (champs comptables) + un bloc par RIB. Le champ **Banque** n'apparaît que si Type de règlement = Virement (RG-3.07). + +## Écran « Modification prestataire » + +Comportement identique à l'écran Ajouter (mêmes formulaires, mêmes RG-3.03 → RG-3.08) sauf : +- **Pas de formulaire principal** réaffiché (champs principaux édités via l'onglet correspondant / pré-remplis). +- Les champs sont **pré-remplis** avec les valeurs actuelles du prestataire. +- **Validation par onglet** : on peut modifier UN onglet sans toucher aux autres (PATCH partiel). +- Les onglets pour lesquels l'utilisateur n'a **pas** la permission `manage` (ou `accounting.manage`) restent en **lecture seule** (pas de bouton Valider, pas d'icône suppression). +- **Accès** : Admin, Bureau (Compta pour l'onglet Comptabilité uniquement). + +## Composants UI à utiliser (`@malio/layer-ui`) + +- **Datatable** : `` (+ `usePaginatedList`) +- **Input texte** : `` +- **Select simple** : `` (Pays, Ville, référentiels comptables) +- **Select multi (cases à cocher)** : `` (Catégorie, Sites, Contacts rattachés) +- **Bouton** : ``, `` +- **Toasts** : standards via `useApi()` +- **Validation par champ** : `useFormErrors` (mapping 422 inline — règle frontend obligatoire) + +**Exceptions autorisées** (commenter `// TODO migrer quand Malio couvre`) : +- Modal de confirmation : `` ou wrapper partagé dans `frontend/shared/` (réutiliser celui du M1/M2). + +## Composables & appels API + +- `usePaginatedList({ url: '/providers' })` — liste paginée (obligatoire). La liste consomme `categories[]` (libellé = `name`) et `sites[]` (libellé = `name`, pas de `code`) **embarqués** + `updatedAt` (cf. [`spec-back.md § 2.12 / § 4.0`](./spec-back.md)). +- `useProvider(id)` — charge le détail via `GET /api/providers/{id}`, qui **embarque** `contacts`, `addresses` (avec `sites` / `categories` / `contacts` imbriqués) et, si permission, `ribs` + scalaires compta. Écrans Consultation et Modification peuplés depuis cette seule réponse (RETEX M1 §2 : embed borné, pas de N+1). **DoD avant intégration** : vérifier que le JSON réel contient ces blocs (cf. [`spec-back.md § 4.0.bis`](./spec-back.md)). +- `useProviderForm()` — workflow par onglet (POST principal + PATCH partiels par groupe), miroir de `useSupplierForm()`. +- `useAddressAutocomplete()` — **réutilisé du M1/M2** (BAN), pas de réécriture. +- `usePermissions()` — masque l'onglet Comptabilité et le bouton Archiver. +- Tous les appels passent par `useApi()` (jamais `$fetch` direct — règle ABSOLUE n°4). +- Filter `formatPhoneFR()` — **réutilisé** pour l'affichage `XX XX XX XX XX`. + +## Règles de formatage et normalisation + +Le serveur normalise systématiquement (RG-3.11 — cf. [`spec-back.md`](./spec-back.md)) : + +| Champ | Normalisation serveur | Affichage front | +|---|---|---| +| Nom prestataire (`companyName`) | UPPERCASE intégral | UPPERCASE | +| Nom + Prénom contact | Capitalize | identique | +| Téléphones (blocs `ProviderContact`) | Chiffres uniquement en BDD | Formaté `XX XX XX XX XX` (filter Vue) | +| Email | lowercase intégral | identique | + +> Le front **ne normalise pas** : il envoie la valeur saisie, le serveur normalise et renvoie la valeur normalisée que l'UI affiche. + +## API adresse postale + +Code postal + Ville + Adresse branchés sur **api-adresse.data.gouv.fr** (BAN) via le composable `useAddressAutocomplete()` **déjà créé au M1/M2** (réutilisé tel quel) : +- À la saisie du CP (5 chiffres) : `GET https://api-adresse.data.gouv.fr/search/?q={cp}&type=municipality` → alimente le select Ville (RG-3.06 : si plusieurs villes, choix dans le select). +- À la saisie d'adresse : `?q={addr}&postcode={cp}&type=housenumber` → suggestions. +- Cas dégradé (timeout / offline) : Ville en `` libre + toast d'avertissement. + +## Différences notables avec le M2 (fournisseurs) + +| Zone | M2 fournisseurs | M3 prestataires | +|---|---|---| +| Onglet Information | 8 champs (Description … Volume) | **Absent** (aucun champ Information) | +| Sélecteur de site sur formulaire principal | Non (sites uniquement via adresses) | **Oui** (RG-3.03 — relation directe `provider.sites`) | +| Type d'adresse | Radio Prospect / Départ / Rendu (RG-2.09) | **Absent** | +| Bennes / Prestation de triage (adresse) | Présents | **Absents** | +| Onglet Transport | Placeholder | **Absent** | +| Onglet Statistiques | Placeholder | **Absent** | +| Onglets « À venir » | Transport / Stats / Rapports / Échanges | **Rapports / Échanges** uniquement | +| Catégories | type `FOURNISSEUR` | **nouveau type `PRESTATAIRE`** | +| Pôle / module | Commercial | **Technique** (nouvelle section sidebar + module back) | +| Cloisonnement par site | aucun | **Visibilité par site, pilotée par l'utilisateur** (bypass via `sites.bypass_scope`) — § 2.13 | + +## Points résolus côté back + +| # | Zone d'ombre | Résolution (cf. `spec-back.md`) | +|---|---|---| +| 1 | Catégorie multi-select | M2M `provider_category`, `Category` de type **PRESTATAIRE** (RG-3.09) | +| 2 | Site sur le formulaire principal | M2M `provider_site` (≥ 1 — RG-3.03), distinct de `provider_address_site` (RG-3.05) | +| 3 | Onglet Comptabilité : qui édite ? | Admin + Compta (`accounting.manage`) ; Bureau/Commerciale ne le voient pas | +| 4 | Workflow par onglet | Sauvegarde incrémentale (POST principal + PATCH partiels) — pas d'état « draft » | +| 5 | Onglets « À venir » | Placeholder minimal « À venir » (Rapports / Échanges) | +| 6 | Archive vs delete | Flag `is_archived` séparé de `deleted_at` ; archivage Admin seul ; soft delete = HP | +| 7 | Unicité métier | Nom de prestataire uniquement (à valider — § 2.6). SIREN/email non uniques | +| 8 | Référentiels comptables | Réutilisés M1/M2 (zéro duplication) ; relation ORM partagée | +| 9 | API code postal | BAN via `useAddressAutocomplete()` du M1/M2 (RG-3.06) | +| 10 | Format export | XLSX uniquement (CSV = HP) | +| 11 | Cloisonnement par site (Usine « son site ») | Filtre back automatique par `currentSite` + bypass `sites.bypass_scope` (§ 2.13 / RG-3.17) | + +--- + +## 📦 Tickets Lesstime + +**TaskGroup Lesstime** : **#29 — M3 — Répertoire prestataires** (projet `ERP / Starseed`, projectId=6) — créé le 11/06/2026, 16 tickets `ERP-131` → `ERP-146`, statut « Prêt à dev », assignés à **Tristan**. + +| # | Ticket | Réf | Tag | +|---|---|---|---| +| 1.1 | Créer module Technique + taxonomie PRESTATAIRE | ERP-131 | Backend | +| 1.2 | Migrer le schéma BDD M3 (provider + sous-collections) | ERP-132 | Backend | +| 1.3 | Créer entités + repositories Provider* | ERP-133 | Backend | +| 1.4 | ProviderProvider + ProviderProcessor + cloisonnement site | ERP-134 | Backend | +| 1.5 | Sous-ressources Contacts / Adresses / RIBs | ERP-135 | Backend | +| 1.6 | Valider les RG métier server-side (RG-3.03→3.09) | ERP-136 | Backend | +| 1.7 | Export XLSX des prestataires | ERP-137 | Backend | +| 1.8 | RBAC technique.providers.* (3 sources) | ERP-138 | Backend | +| 1.9 | PHPUnit RG-3.x + capture contrat JSON | ERP-139 | Backend | +| 1.10 | Page Répertoire (/providers) | ERP-140 | Frontend | +| 1.11 | Page Ajouter (/providers/new) + formulaire principal | ERP-141 | Frontend | +| 1.12 | Onglet Contact | ERP-142 | Frontend | +| 1.13 | Onglet Adresse (autocomplete BAN) | ERP-143 | Frontend | +| 1.14 | Onglet Comptabilité + RIB | ERP-144 | Frontend | +| 1.15 | Pages Consultation + Modification | ERP-145 | Frontend | +| 1.16 | i18n + sidebar Technique + libellés audit | ERP-146 | Frontend | + +> Détail back complet → voir [`spec-back.md § Tickets Lesstime`](./spec-back.md#-tickets-lesstime-à-découper). diff --git a/docs/specs/_RETEX-M1-pour-M2.md b/docs/specs/_RETEX-M1-pour-M2.md new file mode 100644 index 0000000..3d62c81 --- /dev/null +++ b/docs/specs/_RETEX-M1-pour-M2.md @@ -0,0 +1,80 @@ +# RETEX M1 (Clients) → à appliquer pour M2 (Fournisseurs) + +> But : éviter de reproduire en M2 les erreurs de **contrat de sérialisation** qui ont bloqué M1. +> ~80 % des frictions M1 venaient du contrat API (sérialisation / groupes / sous-ressources), **pas** du métier. +> À lire AVANT de rédiger `spec-back.md` et `spec-front.md` du M2, et à garder ouvert pendant la rédaction. + +--- + +## 0. TL;DR (les 3 erreurs à ne jamais refaire) + +1. **Affirmer qu'un champ est « embarqué » sans vérifier les 3 maillons de sérialisation.** En M1 : `Category.code` annoncé dans `client:read`, détail annoncé embarquant contacts/adresses/ribs → **faux dans le code**. Résultat : colonnes liste vides, onglets détail impossibles à peupler. +2. **Livrer des sous-ressources en POST-only** (pas de `GetCollection`, pas d'embed) → le front ne peut pas lister les enfants de l'agrégat. +3. **Écrire la spec/les tickets sur une intention, pas sur le contrat réel.** Le docblock `Client` décrivait un embed jamais implémenté. + +--- + +## 1. Contrat de sérialisation : les 3 maillons obligatoires + +Pour **chaque champ affiché** (liste OU détail), la spec back doit prouver les trois maillons. Si un seul manque → le champ sort en quasi-IRI (`@id`/`@type` seulement) ou pas du tout. + +| Maillon | Question | Exemple M1 raté | +|---|---|---| +| (a) Groupe sur la **propriété** | `#[Groups([...])]` contient-il un read-group ? | `Supplier::$addresses` sans groupe → jamais sérialisé | +| (b) Groupe dans le **`normalizationContext` de l'opération** | l'opération (`GetCollection`/`Get`) liste-t-elle ce groupe ? | `GetCollection` en `['client:read','default:read']` | +| (c) Read-group de l'**entité imbriquée** dans le contexte parent | pour embarquer les champs d'une relation (catégorie, site…), le contexte parent inclut-il `category:read` / `site:read` ? | `Category.code` ∈ `category:read`, absent du contexte client → pas de `code` | + +**Règle de rédaction** : dans `spec-back.md`, faire un tableau « champ → groupe propriété → groupe(s) à ajouter au contexte de chaque opération » pour la liste ET le détail. Inclure explicitement les **relations imbriquées** (ex. catégories d'une adresse, sites d'une adresse). + +## 2. Collections enfant d'un agrégat : décider embed vs GetCollection, et câbler en ENTIER + +Décision à acter dès la spec back pour chaque sous-collection (contacts, adresses, RIB, lignes…) : + +- **Embed dans le détail (recommandé pour un agrégat DDD)** : poser `#[Groups([':item:read'])]` sur la propriété + ajouter au `normalizationContext` du `Get` racine les read-groups des entités enfant **et** de leurs relations imbriquées. 1 requête, cohérent avec un composable `useX(id)`. Réservé aux ensembles **bornés** (ne viole pas la règle n°13 : elle vise les collections exposées, pas un embed borné d'item). +- **GetCollection sous-ressource** : `//{id}/children` paginé. À réserver aux collections potentiellement volumineuses. Si choisi, **créer l'opération** (pas seulement POST). + +❌ Anti-pattern M1 : sous-ressources avec `POST` + `Get` unitaire seulement → **aucun moyen de lister** (ids non découvrables). Interdit. + +## 3. Vérifier le contrat sur l'API RÉELLE avant d'écrire les tickets front + +Le blocage M1 (codes/sites/sous-collections) aurait été vu en 5 min. À mettre dans la **definition of done de la spec back** : + +> Créer un enregistrement de test, appeler `GET /api/` (liste) ET `GET /api//{id}` (détail), **coller la réponse JSON réelle** dans la spec. Toute donnée affichée par le front doit apparaître dans ce JSON collé. + +## 4. La spec décrit le RÉEL, pas l'intention + +- Bannir les « devrait être embarqué », « est exposé » non vérifiés. Décrire ce qui existe (ou ce qui sera livré dans le ticket, en le marquant clairement « à livrer »). +- Si un docblock/commentaire existant contredit le code, le **corriger**, pas le recopier. + +## 5. Réutiliser les acquis M1 (ne pas réinventer) + +- **Taxonomie ERP-78** : si M2 catégorise les fournisseurs, repartir du modèle **type unique + `code` stable** (slug MAJUSCULE auto-généré, NOT NULL, figé, **lecture seule** `category:read`), filtrage métier via `?categoryCode=`. Réutiliser le contrat partagé `CategoryInterface` (pas d'import inter-module). +- **Front** : `usePaginatedList` (listes), composants `Malio*`, `useApi()`, `formatPhoneFR`, blocs réutilisables (Contact/Adresse), pattern de blocs dynamiques + modal de confirmation. +- **Archive** : flag `is_archived` **distinct** de `deleted_at` (soft delete). Restauration → gérer le 409 homonyme. +- **Normalisation = serveur** (UPPERCASE nom société, Capitalize noms, lowercase email, téléphone en chiffres). Le front envoie la saisie, réaffiche la valeur normalisée renvoyée. À documenter dans la spec. +- **Gating fin + mode strict PATCH** : PATCH par groupe de sérialisation ; tout champ hors-permission dans le payload = **403 sur l'intégralité** (pas de filtrage silencieux). Spécifier la matrice rôle × onglet. + +## 6. Règles ABSOLUES transverses à rappeler dans la spec M2 + +- **Pagination obligatoire** (règle n°13) sur toute `GetCollection` ; échappatoire `?pagination=false` réservée aux selects de référentiels bornés. +- **`COMMENT ON COLUMN`** (règle n°12) sur chaque colonne créée/modifiée (sinon `make test` casse). Helper standard pour les colonnes Timestampable/Blamable. +- **Timestampable + Blamable** sur toute nouvelle entité métier (4 colonnes + trait) ; garde-fou archi. +- **`#[Auditable]`** sur les entités métier ; **`#[AuditIgnore]`** sur les champs sensibles (équivalents BIC/IBAN/secret). +- **`declare(strict_types=1);`** partout ; commentaires FR, code EN. +- **Routes front à plat** (pas de préfixe module), état tableau **jamais** dans l'URL. +- **3 miroirs RBAC** à toucher ensemble : `config/sidebar.php`, `frontend/tests/e2e/_fixtures/personas.ts`, `SeedE2ECommand.php`. +- **Communication inter-module** uniquement via `Shared/Domain/Contract/` ou domain events — jamais d'import direct. + +## 7. Fixtures & seed dès le départ + +M1 a subi un aller-retour (ERP-68) faute de fixtures alignées. Pour M2 : prévoir dès la spec un seed de fournisseurs démo **couvrant tous les cas des règles métier** (relations, catégories codées, archivés, cas comptables) + comptes de rôles démo, pour vérifier le gating et le golden path sans bricolage. + +## 8. Mini-checklist de relecture de la spec M2 (avant de la déclarer prête) + +- [ ] Chaque champ affiché (liste + détail) a ses 3 maillons de sérialisation documentés (propriété, contexte opération, relations imbriquées). +- [ ] Chaque sous-collection a une décision **embed vs GetCollection** explicite et **complètement câblée** (pas de POST-only). +- [ ] Réponses JSON réelles (liste + détail) collées dans la spec back. +- [ ] Matrice RBAC rôle × écran × onglet + mode strict PATCH spécifiés. +- [ ] Pagination, COMMENT ON COLUMN, Timestampable/Blamable, Audit, routes à plat : rappelés. +- [ ] Réutilisations M1 identifiées (taxonomie code, usePaginatedList, blocs, archive, normalisation). +- [ ] Seed/fixtures démo planifiés. diff --git a/frontend/i18n/locales/fr.json b/frontend/i18n/locales/fr.json index d3ea681..7f8819b 100644 --- a/frontend/i18n/locales/fr.json +++ b/frontend/i18n/locales/fr.json @@ -413,7 +413,11 @@ "commercial_supplier": "Fournisseur", "commercial_supplieraddress": "Adresse fournisseur", "commercial_suppliercontact": "Contact fournisseur", - "commercial_supplierrib": "RIB fournisseur" + "commercial_supplierrib": "RIB fournisseur", + "technique_provider": "Prestataire", + "technique_provideraddress": "Adresse prestataire", + "technique_providercontact": "Contact prestataire", + "technique_providerrib": "RIB prestataire" }, "empty": "Aucune activité enregistrée", "no_results": "Aucun résultat pour ces filtres", diff --git a/frontend/modules/technique/nuxt.config.ts b/frontend/modules/technique/nuxt.config.ts new file mode 100644 index 0000000..268da7f --- /dev/null +++ b/frontend/modules/technique/nuxt.config.ts @@ -0,0 +1 @@ +export default defineNuxtConfig({}) diff --git a/makefile b/makefile index b749e4b..49dfc12 100644 --- a/makefile +++ b/makefile @@ -231,6 +231,7 @@ test-db-setup: $(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_category_code ON category (code) WHERE deleted_at IS NULL" $(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_client_company_name_active ON client (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL" $(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_supplier_company_name_active ON supplier (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL" + $(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_provider_company_name_active ON provider (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL" fixtures: $(SYMFONY_CONSOLE) --no-interaction doctrine:fixtures:load diff --git a/migrations/Version20260612080000.php b/migrations/Version20260612080000.php new file mode 100644 index 0000000..bf4d7cd --- /dev/null +++ b/migrations/Version20260612080000.php @@ -0,0 +1,121 @@ + pas de `COMMENT ON COLUMN` (regle ABSOLUE n°12) : + * la migration ne fait que des INSERT de donnees de reference. + * + * Namespace racine `DoctrineMigrations` (regle ABSOLUE n°11) et NON modulaire : + * avec plusieurs migrations_paths, Doctrine Migrations 3.x trie par FQCN + * alphabetique -> une migration `App\Module\...` passerait avant les + * `DoctrineMigrations\...` sur base vide, donc avant la creation des tables + * `category` / `category_type` / `category_category_type`. Le namespace racine + * garantit l'ordre par timestamp. + * + * Idempotence : `INSERT ... ON CONFLICT (code) DO NOTHING` pour le type, + * `INSERT ... SELECT ... WHERE NOT EXISTS` pour chaque categorie et chaque ligne + * de jonction (aligne sur le pattern ERP-84 / Version20260605120000). En prod la + * table `category` est vide (aucune fixture metier). En dev/test, le purger + * Doctrine vide `category` / `category_type` avant les fixtures qui reproduisent + * le meme etat final (CategoryTypeFixtures / CategoryFixtures etendus a PRESTATAIRE). + */ +final class Version20260612080000 extends AbstractMigration +{ + /** + * Categories de demonstration du type PRESTATAIRE : nom => code stable. Le + * code est la cle metier (slug MAJUSCULE du nom, miroir du + * CategoryCodeGenerator) et reste unique parmi les actifs (uq_category_code, + * partage avec les codes CLIENT / FOURNISSEUR — aucune collision ici). Le nom + * est unique GLOBALEMENT parmi les actifs (uq_category_name_active) : les + * libelles ci-dessous n'entrent en collision avec aucune categorie seedee. + */ + private const array PROVIDER_CATEGORIES = [ + 'Maintenance industrielle' => 'MAINTENANCE_INDUSTRIELLE', + 'Nettoyage' => 'NETTOYAGE', + 'Transport' => 'TRANSPORT', + ]; + + public function getDescription(): string + { + return 'M3 1.1 : cree le CategoryType PRESTATAIRE + seed des categories prestataires (Maintenance industrielle, Nettoyage, Transport).'; + } + + public function up(Schema $schema): void + { + // 1. Type PRESTATAIRE (idempotent via l'index unique uq_category_type_code). + $this->addSql(<<<'SQL' + INSERT INTO category_type (code, label) VALUES ('PRESTATAIRE', 'Prestataire') + ON CONFLICT (code) DO NOTHING + SQL); + + foreach (self::PROVIDER_CATEGORIES as $name => $code) { + // 2a. Categorie sous PRESTATAIRE (si le code est libre parmi les + // actifs). created_at/updated_at NOT NULL -> NOW() ; le blame + // reste null (seed hors contexte HTTP, libelle « Systeme » cote front). + $this->addSql(<<<'SQL' + INSERT INTO category (name, code, created_at, updated_at) + SELECT :name, :code, NOW(), NOW() + WHERE NOT EXISTS ( + SELECT 1 FROM category c WHERE c.code = :code AND c.deleted_at IS NULL + ) + SQL, ['name' => $name, 'code' => $code]); + + // 2b. Jonction M2M categorie <-> type PRESTATAIRE (modele courant). + $this->addSql(<<<'SQL' + INSERT INTO category_category_type (category_id, category_type_id) + SELECT c.id, ct.id + FROM category c + CROSS JOIN category_type ct + WHERE c.code = :code AND c.deleted_at IS NULL + AND ct.code = 'PRESTATAIRE' + AND NOT EXISTS ( + SELECT 1 FROM category_category_type cct + WHERE cct.category_id = c.id AND cct.category_type_id = ct.id + ) + SQL, ['code' => $code]); + } + } + + public function down(Schema $schema): void + { + // Best-effort : on retire d'abord les categories seedees (par code) — la FK + // category_category_type est ON DELETE CASCADE cote category, donc les + // lignes de jonction partent avec —, puis le type s'il n'est plus reference. + $this->addSql( + 'DELETE FROM category WHERE code IN (:codes) ' + ."AND id IN (SELECT category_id FROM category_category_type cct " + ."JOIN category_type ct ON ct.id = cct.category_type_id WHERE ct.code = 'PRESTATAIRE')", + ['codes' => array_values(self::PROVIDER_CATEGORIES)], + ['codes' => ArrayParameterType::STRING], + ); + + $this->addSql(<<<'SQL' + DELETE FROM category_type + WHERE code = 'PRESTATAIRE' + AND NOT EXISTS ( + SELECT 1 FROM category_category_type cct WHERE cct.category_type_id = category_type.id + ) + SQL); + } +} diff --git a/migrations/Version20260612100000.php b/migrations/Version20260612100000.php new file mode 100644 index 0000000..9ee3aec --- /dev/null +++ b/migrations/Version20260612100000.php @@ -0,0 +1,451 @@ += 1). Sert aussi le cloisonnement + * par site (idx_provider_site_site, § 2.13). + * - provider_address SIMPLIFIEE : pas de address_type / bennes / + * triage_provider (specifiques fournisseur). Champs : country / postal_code + * / city / street / street_complement / position + M2M sites/contacts/categories. + * + * Referentiels comptables NON recrees : tva_mode / payment_delay / payment_type + * / bank sont ceux du M1 (FK partagees, zero duplication — spec § 2.3). + * + * CategoryType PRESTATAIRE NON re-seede : il est cree par ERP-131 + * (Version20260612080000) avec ses categories de demonstration. Le M2M + * provider_category / provider_address_category s appuie sur ce type existant. + * + * Namespace racine `DoctrineMigrations` (regle ABSOLUE Starseed n°11) et NON + * `App\Module\Technique\...` : la migration cree un schema avec FK cross-module + * (user, category, site, et les referentiels comptables M1). Avec plusieurs + * migrations_paths, Doctrine Migrations 3.x trie par FQCN alphabetique — un + * namespace modulaire s executerait avant la creation de user/category/site sur + * base vide -> echec des FK. Le namespace racine garantit l ordre par timestamp. + * + * Style DDL aligne sur le M1/M2 (Version20260605130000) : `INT GENERATED BY + * DEFAULT AS IDENTITY` (et non SERIAL), `TIMESTAMP(0) WITHOUT TIME ZONE` (et non + * TIMESTAMPTZ, car le TimestampableBlamableTrait mappe `datetime_immutable`). + * Garantit que `schema:update` restera un no-op quand les entites arriveront + * (ticket ERP-133). + * + * Decision unicite (alignee Q4 M1 / § 2.6 M2) : unicite metier sur le NOM DE + * SOCIETE uniquement (uq_provider_company_name_active, partiel). Pas d index + * unique sur siren ni email. + * + * COMMENT ON COLUMN inline (regle ABSOLUE n°12) : chaque colonne metier porte sa + * description ici-meme. Volontairement NON ajoutees a `ColumnCommentsCatalog` / + * `makefile test-db-setup` a ce stade : tant que les entites Provider* n existent + * pas (ERP-133), `schema:update --force` du setup de test droppe ces tables non + * mappees — les referencer dans le catalogue ferait planter + * `app:apply-column-comments`. Le catalogue + la ligne `dbal:run-sql` + * (uq_provider_company_name_active) seront ajoutes au ticket entites (ERP-133), + * exactement comme supplier (ERP-86) apres sa migration (ERP-85). Les 4 colonnes + * Timestampable/Blamable reutilisent les textes standardises du catalogue + * (`timestampableBlamableComments()`, simple tableau statique sans dependance DB). + */ +final class Version20260612100000 extends AbstractMigration +{ + public function getDescription(): string + { + return 'ERP-132 (M3) : tables provider + sous-collections + jointures M2M (referentiels comptables et CategoryType PRESTATAIRE reutilises).'; + } + + public function up(Schema $schema): void + { + $this->createProviderTable(); + $this->createProviderCategory(); + $this->createProviderSite(); + $this->createProviderContact(); + $this->createProviderAddress(); + $this->createProviderAddressJoinTables(); + $this->createProviderRib(); + } + + public function down(Schema $schema): void + { + // Ordre inverse des dependances FK : jointures et sous-collections + // d abord, puis provider. Les referentiels comptables et le + // CategoryType PRESTATAIRE ne sont pas touches (crees ailleurs). + $this->addSql('DROP TABLE IF EXISTS provider_address_category'); + $this->addSql('DROP TABLE IF EXISTS provider_address_contact'); + $this->addSql('DROP TABLE IF EXISTS provider_address_site'); + $this->addSql('DROP TABLE IF EXISTS provider_rib'); + $this->addSql('DROP TABLE IF EXISTS provider_address'); + $this->addSql('DROP TABLE IF EXISTS provider_contact'); + $this->addSql('DROP TABLE IF EXISTS provider_site'); + $this->addSql('DROP TABLE IF EXISTS provider_category'); + $this->addSql('DROP TABLE IF EXISTS provider'); + } + + // ================================================================= + // Table principale `provider` + // ================================================================= + + private function createProviderTable(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider ( + id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL, + company_name VARCHAR(180) NOT NULL, + siren VARCHAR(20) DEFAULT NULL, + account_number VARCHAR(40) DEFAULT NULL, + tva_mode_id INT DEFAULT NULL, + n_tva VARCHAR(40) DEFAULT NULL, + payment_delay_id INT DEFAULT NULL, + payment_type_id INT DEFAULT NULL, + bank_id INT DEFAULT NULL, + is_archived BOOLEAN DEFAULT FALSE NOT NULL, + archived_at TIMESTAMP(0) WITHOUT TIME ZONE DEFAULT NULL, + deleted_at TIMESTAMP(0) WITHOUT TIME ZONE DEFAULT NULL, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT DEFAULT NULL, + updated_by INT DEFAULT NULL, + PRIMARY KEY (id), + CONSTRAINT fk_provider_tva_mode + FOREIGN KEY (tva_mode_id) REFERENCES tva_mode (id) ON DELETE RESTRICT, + CONSTRAINT fk_provider_payment_delay + FOREIGN KEY (payment_delay_id) REFERENCES payment_delay (id) ON DELETE RESTRICT, + CONSTRAINT fk_provider_payment_type + FOREIGN KEY (payment_type_id) REFERENCES payment_type (id) ON DELETE RESTRICT, + CONSTRAINT fk_provider_bank + FOREIGN KEY (bank_id) REFERENCES bank (id) ON DELETE RESTRICT, + CONSTRAINT fk_provider_created_by + FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL, + CONSTRAINT fk_provider_updated_by + FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL + ) + SQL); + + $this->addSql('CREATE INDEX idx_provider_is_archived ON provider (is_archived)'); + $this->addSql('CREATE INDEX idx_provider_deleted_at ON provider (deleted_at)'); + $this->addSql('CREATE INDEX idx_provider_created_by ON provider (created_by)'); + $this->addSql('CREATE INDEX idx_provider_updated_by ON provider (updated_by)'); + + // Index sur les FK des referentiels comptables (Postgres n indexe pas + // automatiquement les colonnes portant une FOREIGN KEY). + $this->addSql('CREATE INDEX idx_provider_tva_mode_id ON provider (tva_mode_id)'); + $this->addSql('CREATE INDEX idx_provider_payment_delay_id ON provider (payment_delay_id)'); + $this->addSql('CREATE INDEX idx_provider_payment_type_id ON provider (payment_type_id)'); + $this->addSql('CREATE INDEX idx_provider_bank_id ON provider (bank_id)'); + + // Unicite metier partielle : nom de societe insensible a la casse, parmi + // les non-archives ET non soft-deletes uniquement (RG-3.10). Pas d index + // unique sur siren ni email. + $this->addSql(<<<'SQL' + CREATE UNIQUE INDEX uq_provider_company_name_active + ON provider (LOWER(company_name)) + WHERE is_archived = FALSE AND deleted_at IS NULL + SQL); + + $this->comment('provider', '_table', 'Repertoire prestataires (M3 Technique) — entites archivables (is_archived) et soft-deletables (deleted_at, HP M4). Pas d onglet Information (≠ supplier).'); + $this->comment('provider', 'id', 'Identifiant interne auto-incremente.'); + $this->comment('provider', 'company_name', 'Raison sociale du prestataire (stockee en MAJUSCULES). Unique case-insensitive parmi les actifs non archives/non supprimes (uq_provider_company_name_active, RG-3.10).'); + $this->comment('provider', 'siren', 'Onglet Comptabilite : SIREN (9 chiffres attendus). NON unique — peut etre partage entre etablissements (RG-3.10).'); + $this->comment('provider', 'account_number', 'Onglet Comptabilite : numero de compte comptable du prestataire.'); + $this->comment('provider', 'tva_mode_id', 'Onglet Comptabilite : mode de TVA applique — FK -> tva_mode.id (referentiel partage M1), ON DELETE RESTRICT.'); + $this->comment('provider', 'n_tva', 'Onglet Comptabilite : numero de TVA intracommunautaire.'); + $this->comment('provider', 'payment_delay_id', 'Onglet Comptabilite : delai de reglement — FK -> payment_delay.id (M1), ON DELETE RESTRICT.'); + $this->comment('provider', 'payment_type_id', 'Onglet Comptabilite : type de reglement — FK -> payment_type.id (M1), ON DELETE RESTRICT. Pilote RG-3.07 (Banque si VIREMENT) et RG-3.08 (RIB).'); + $this->comment('provider', 'bank_id', 'Onglet Comptabilite : banque — FK -> bank.id (M1), ON DELETE RESTRICT. Obligatoire ssi payment_type = VIREMENT (RG-3.07), null sinon.'); + $this->comment('provider', 'is_archived', 'Drapeau fonctionnel d archivage — masque par defaut dans la liste. Bascule via permission technique.providers.archive.'); + $this->comment('provider', 'archived_at', 'Horodatage de l archivage — pose quand is_archived passe a vrai, remis a null a la restauration.'); + $this->comment('provider', 'deleted_at', 'Horodatage du soft-delete technique (HP M4) — non expose par l API au M3. Null = ligne active.'); + $this->addTimestampableBlamableComments('provider'); + } + + // ================================================================= + // M2M provider <-> category (type PRESTATAIRE — RG-3.09) + // ================================================================= + + private function createProviderCategory(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_category ( + provider_id INT NOT NULL, + category_id INT NOT NULL, + PRIMARY KEY (provider_id, category_id), + CONSTRAINT fk_provider_category_provider + FOREIGN KEY (provider_id) REFERENCES provider (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_category_category + FOREIGN KEY (category_id) REFERENCES category (id) ON DELETE RESTRICT + ) + SQL); + $this->addSql('CREATE INDEX idx_provider_category_category ON provider_category (category_id)'); + + $this->comment('provider_category', '_table', 'Jointure M2M provider <-> category (Catalog) — categories de type PRESTATAIRE du prestataire, au moins une obligatoire (RG-3.09).'); + $this->comment('provider_category', 'provider_id', 'FK -> provider.id, ON DELETE CASCADE — prestataire porteur de la categorie.'); + $this->comment('provider_category', 'category_id', 'FK -> category.id, ON DELETE RESTRICT — categorie de type PRESTATAIRE rattachee au prestataire (RG-3.09).'); + } + + // ================================================================= + // M2M provider <-> site (formulaire principal — RG-3.03) + // ================================================================= + + private function createProviderSite(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_site ( + provider_id INT NOT NULL, + site_id INT NOT NULL, + PRIMARY KEY (provider_id, site_id), + CONSTRAINT fk_provider_site_provider + FOREIGN KEY (provider_id) REFERENCES provider (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_site_site + FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE RESTRICT + ) + SQL); + // Index sur site_id : sert le filtre de cloisonnement par site + // (WHERE site = :currentSite, § 2.13). + $this->addSql('CREATE INDEX idx_provider_site_site ON provider_site (site_id)'); + + $this->comment('provider_site', '_table', 'Jointure M2M provider <-> site (Sites) — sites du prestataire, selecteur du formulaire principal, au moins un obligatoire (RG-3.03). Sert le cloisonnement par site (§ 2.13).'); + $this->comment('provider_site', 'provider_id', 'FK -> provider.id, ON DELETE CASCADE — prestataire porteur du site.'); + $this->comment('provider_site', 'site_id', 'FK -> site.id, ON DELETE RESTRICT — site rattache au prestataire (RG-3.03, idx_provider_site_site).'); + } + + // ================================================================= + // Sous-collection : contacts (1:n) + // ================================================================= + + private function createProviderContact(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_contact ( + id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL, + provider_id INT NOT NULL, + first_name VARCHAR(120) DEFAULT NULL, + last_name VARCHAR(120) DEFAULT NULL, + job_title VARCHAR(120) DEFAULT NULL, + phone_primary VARCHAR(20) DEFAULT NULL, + phone_secondary VARCHAR(20) DEFAULT NULL, + email VARCHAR(180) DEFAULT NULL, + position INT DEFAULT 0 NOT NULL, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT DEFAULT NULL, + updated_by INT DEFAULT NULL, + PRIMARY KEY (id), + CONSTRAINT chk_provider_contact_name + CHECK (first_name IS NOT NULL OR last_name IS NOT NULL OR phone_primary IS NOT NULL OR email IS NOT NULL), + CONSTRAINT fk_provider_contact_provider + FOREIGN KEY (provider_id) REFERENCES provider (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_contact_created_by + FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL, + CONSTRAINT fk_provider_contact_updated_by + FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL + ) + SQL); + $this->addSql('CREATE INDEX idx_provider_contact_provider ON provider_contact (provider_id)'); + + $this->comment('provider_contact', '_table', 'Contacts d un prestataire (1:n) — au moins un champ rempli parmi prenom/nom/telephone/email (RG-3.04, chk_provider_contact_name).'); + $this->comment('provider_contact', 'id', 'Identifiant interne auto-incremente.'); + $this->comment('provider_contact', 'provider_id', 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire du contact.'); + $this->comment('provider_contact', 'first_name', 'Prenom du contact (capitalise serveur). Au moins un champ du contact requis (RG-3.04, chk_provider_contact_name).'); + $this->comment('provider_contact', 'last_name', 'Nom du contact (capitalise serveur). Au moins un champ du contact requis (RG-3.04, chk_provider_contact_name).'); + $this->comment('provider_contact', 'job_title', 'Fonction / intitule de poste du contact (≤ 120 caracteres).'); + $this->comment('provider_contact', 'phone_primary', 'Telephone principal du contact — chiffres uniquement (normalisation serveur).'); + $this->comment('provider_contact', 'phone_secondary', 'Telephone secondaire du contact — chiffres uniquement (normalisation serveur).'); + $this->comment('provider_contact', 'email', 'Email du contact (lowercase serveur).'); + $this->comment('provider_contact', 'position', 'Ordre d affichage du contact dans la liste du prestataire (croissant).'); + $this->addTimestampableBlamableComments('provider_contact'); + } + + // ================================================================= + // Sous-collection : adresses (1:n) — SANS address_type / bennes / triage + // ================================================================= + + private function createProviderAddress(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_address ( + id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL, + provider_id INT NOT NULL, + country VARCHAR(80) DEFAULT 'France' NOT NULL, + postal_code VARCHAR(20) NOT NULL, + city VARCHAR(120) NOT NULL, + street VARCHAR(255) NOT NULL, + street_complement VARCHAR(255) DEFAULT NULL, + position INT DEFAULT 0 NOT NULL, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT DEFAULT NULL, + updated_by INT DEFAULT NULL, + PRIMARY KEY (id), + CONSTRAINT fk_provider_address_provider + FOREIGN KEY (provider_id) REFERENCES provider (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_address_created_by + FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL, + CONSTRAINT fk_provider_address_updated_by + FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL + ) + SQL); + $this->addSql('CREATE INDEX idx_provider_address_provider ON provider_address (provider_id)'); + + $this->comment('provider_address', '_table', 'Adresses d un prestataire (1:n) — >= 1 site rattache (RG-3.05). SANS address_type / bennes / triage_provider (specifiques fournisseur).'); + $this->comment('provider_address', 'id', 'Identifiant interne auto-incremente.'); + $this->comment('provider_address', 'provider_id', 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire de l adresse.'); + $this->comment('provider_address', 'country', 'Pays de l adresse — defaut France.'); + $this->comment('provider_address', 'postal_code', 'Code postal (4-5 chiffres attendus) — declenche l autocompletion ville via l API BAN cote front (RG-3.06).'); + $this->comment('provider_address', 'city', 'Ville — preremplie depuis le code postal via API BAN cote front.'); + $this->comment('provider_address', 'street', 'Numero et voie de l adresse.'); + $this->comment('provider_address', 'street_complement', 'Complement d adresse (etage, batiment...) — optionnel.'); + $this->comment('provider_address', 'position', 'Ordre d affichage de l adresse dans la liste du prestataire (croissant).'); + $this->addTimestampableBlamableComments('provider_address'); + } + + // ================================================================= + // Jointures de provider_address (M2M) + // ================================================================= + + private function createProviderAddressJoinTables(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_address_site ( + provider_address_id INT NOT NULL, + site_id INT NOT NULL, + PRIMARY KEY (provider_address_id, site_id), + CONSTRAINT fk_provider_address_site_address + FOREIGN KEY (provider_address_id) REFERENCES provider_address (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_address_site_site + FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE RESTRICT + ) + SQL); + $this->comment('provider_address_site', '_table', 'Jointure M2M provider_address <-> site (Sites) — sites rattaches a l adresse (>= 1 obligatoire, RG-3.05).'); + $this->comment('provider_address_site', 'provider_address_id', 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.'); + $this->comment('provider_address_site', 'site_id', 'FK -> site.id, ON DELETE RESTRICT — site rattache a l adresse.'); + + $this->addSql(<<<'SQL' + CREATE TABLE provider_address_contact ( + provider_address_id INT NOT NULL, + provider_contact_id INT NOT NULL, + PRIMARY KEY (provider_address_id, provider_contact_id), + CONSTRAINT fk_provider_address_contact_address + FOREIGN KEY (provider_address_id) REFERENCES provider_address (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_address_contact_contact + FOREIGN KEY (provider_contact_id) REFERENCES provider_contact (id) ON DELETE CASCADE + ) + SQL); + $this->comment('provider_address_contact', '_table', 'Jointure M2M provider_address <-> provider_contact — contacts associes a une adresse.'); + $this->comment('provider_address_contact', 'provider_address_id', 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.'); + $this->comment('provider_address_contact', 'provider_contact_id', 'FK -> provider_contact.id, ON DELETE CASCADE — contact associe a l adresse.'); + + $this->addSql(<<<'SQL' + CREATE TABLE provider_address_category ( + provider_address_id INT NOT NULL, + category_id INT NOT NULL, + PRIMARY KEY (provider_address_id, category_id), + CONSTRAINT fk_provider_address_category_address + FOREIGN KEY (provider_address_id) REFERENCES provider_address (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_address_category_category + FOREIGN KEY (category_id) REFERENCES category (id) ON DELETE RESTRICT + ) + SQL); + $this->comment('provider_address_category', '_table', 'Jointure M2M provider_address <-> category — categories d adresse de type PRESTATAIRE (RG-3.09).'); + $this->comment('provider_address_category', 'provider_address_id', 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.'); + $this->comment('provider_address_category', 'category_id', 'FK -> category.id, ON DELETE RESTRICT — categorie d adresse de type PRESTATAIRE (RG-3.09).'); + } + + // ================================================================= + // Sous-collection : RIB (1:n) + // ================================================================= + + private function createProviderRib(): void + { + $this->addSql(<<<'SQL' + CREATE TABLE provider_rib ( + id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL, + provider_id INT NOT NULL, + label VARCHAR(120) NOT NULL, + bic VARCHAR(20) NOT NULL, + iban VARCHAR(34) NOT NULL, + position INT DEFAULT 0 NOT NULL, + created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, + created_by INT DEFAULT NULL, + updated_by INT DEFAULT NULL, + PRIMARY KEY (id), + CONSTRAINT fk_provider_rib_provider + FOREIGN KEY (provider_id) REFERENCES provider (id) ON DELETE CASCADE, + CONSTRAINT fk_provider_rib_created_by + FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL, + CONSTRAINT fk_provider_rib_updated_by + FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL + ) + SQL); + $this->addSql('CREATE INDEX idx_provider_rib_provider ON provider_rib (provider_id)'); + + $this->comment('provider_rib', '_table', 'Coordonnees bancaires d un prestataire (1:n) — >= 1 RIB attendu selon le type de reglement (RG-3.08). Tous les champs audites (pas d AuditIgnore).'); + $this->comment('provider_rib', 'id', 'Identifiant interne auto-incremente.'); + $this->comment('provider_rib', 'provider_id', 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire du RIB.'); + $this->comment('provider_rib', 'label', 'Libelle du RIB (ex: compte principal).'); + $this->comment('provider_rib', 'bic', 'Code BIC/SWIFT de la banque (8 ou 11 caracteres).'); + $this->comment('provider_rib', 'iban', 'IBAN du compte (≤ 34 caracteres).'); + $this->comment('provider_rib', 'position', 'Ordre d affichage du RIB dans la liste du prestataire (croissant).'); + $this->addTimestampableBlamableComments('provider_rib'); + } + + // ================================================================= + // Helpers + // ================================================================= + + /** + * Pose les 4 commentaires standardises Timestampable/Blamable sur une table, + * en reutilisant le catalogue partage (source unique, cf. ERP-67). Seul le + * tableau statique des textes est reutilise — aucune dependance a l etat DB. + */ + private function addTimestampableBlamableComments(string $table): void + { + foreach (ColumnCommentsCatalog::timestampableBlamableComments() as $column => $description) { + $this->comment($table, $column, $description); + } + } + + /** + * Emet un `COMMENT ON TABLE` (colonne speciale `_table`) ou + * `COMMENT ON COLUMN` en dollar-quoting Postgres ($_$...$_$) pour eviter + * tout echappement d apostrophe. + */ + private function comment(string $table, string $column, string $description): void + { + $quotedTable = '"'.str_replace('"', '""', $table).'"'; + + if ('_table' === $column) { + $this->addSql(sprintf('COMMENT ON TABLE %s IS $_$%s$_$', $quotedTable, $description)); + + return; + } + + $this->addSql(sprintf( + 'COMMENT ON COLUMN %s.%s IS $_$%s$_$', + $quotedTable, + '"'.str_replace('"', '""', $column).'"', + $description, + )); + } +} diff --git a/src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php b/src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php index 760cf89..b150a45 100644 --- a/src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php +++ b/src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php @@ -17,7 +17,9 @@ use Symfony\Component\DependencyInjection\Attribute\Autowire; * Fixtures dev/test du module Catalog : categories de demonstration rattachees * a leur CategoryType. Le type CLIENT porte ~11 categories clients (refonte * taxonomie ERP-78) ; le type FOURNISSEUR porte les categories fournisseurs - * (ERP-84 : Negociant, Cooperative...). Chaque categorie porte un `code` stable. + * (ERP-84 : Negociant, Cooperative...) ; le type PRESTATAIRE porte les categories + * prestataires (M3 1.1 : Maintenance industrielle, Nettoyage, Transport). Chaque + * categorie porte un `code` stable. * Alimente le repertoire clients (ClientFixtures, module Commercial) avec des * donnees realistes couvrant RG-1.03 (codes DISTRIBUTEUR / COURTIER) et RG-1.29 * (codes interdits sur adresse), et le multi-select Categorie fournisseur (M2). @@ -71,6 +73,11 @@ class CategoryFixtures extends Fixture implements DependentFixtureInterface 'Grossiste' => 'GROSSISTE', 'Importateur' => 'IMPORTATEUR', ], + 'PRESTATAIRE' => [ + 'Maintenance industrielle' => 'MAINTENANCE_INDUSTRIELLE', + 'Nettoyage' => 'NETTOYAGE', + 'Transport' => 'TRANSPORT', + ], ]; public function __construct( diff --git a/src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php b/src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php index b329414..8d5c518 100644 --- a/src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php +++ b/src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php @@ -21,6 +21,10 @@ use Doctrine\Persistence\ObjectManager; * taxonomie distincte des fournisseurs (Negociant, Cooperative...). Mirroir de * la migration Version20260605120000. * + * M3 1.1 : ajout du type PRESTATAIRE (code PRESTATAIRE, label « Prestataire »), + * taxonomie distincte des prestataires (Maintenance industrielle, Nettoyage, + * Transport). Mirroir de la migration Version20260612080000. + * * Pourquoi une fixture EN PLUS du seed de la migration : `category_type` est une * entite managee par l ORM, donc le purger Doctrine la vide avant chaque * `doctrine:fixtures:load`. Sans cette fixture, le type CLIENT seede par la @@ -36,12 +40,13 @@ class CategoryTypeFixtures extends Fixture { /** * Source unique des types : code technique => libelle FR. Doit rester aligne - * sur le seed des migrations Version20260602100000 (CLIENT) et - * Version20260605120000 (FOURNISSEUR). + * sur le seed des migrations Version20260602100000 (CLIENT), + * Version20260605120000 (FOURNISSEUR) et Version20260612080000 (PRESTATAIRE). */ private const TYPES = [ 'CLIENT' => 'Client', 'FOURNISSEUR' => 'Fournisseur', + 'PRESTATAIRE' => 'Prestataire', ]; public function __construct( diff --git a/src/Module/Technique/Application/Service/ProviderFieldNormalizer.php b/src/Module/Technique/Application/Service/ProviderFieldNormalizer.php new file mode 100644 index 0000000..facc4c0 --- /dev/null +++ b/src/Module/Technique/Application/Service/ProviderFieldNormalizer.php @@ -0,0 +1,82 @@ + "0612345678" (RG-3.11). + * Le formatage d'affichage "XX XX XX XX XX" est de la responsabilite du front. + * - email : lowercase integral (RG-3.11) + * + * Toutes les methodes sont null-safe et trim-ent l'entree ; une chaine vide + * apres trim devient null (evite de persister "" dans des colonnes nullable). + */ +final class ProviderFieldNormalizer +{ + /** + * Nom de societe en majuscules (RG-3.11). Conserve null tel quel ; une + * chaine non vide est trim + upper. Une chaine vide reste "" (champ + * obligatoire : c'est l'Assert\NotBlank qui rejette, pas le normalizer). + */ + public function normalizeCompanyName(?string $value): ?string + { + if (null === $value) { + return null; + } + + return mb_strtoupper(trim($value), 'UTF-8'); + } + + /** + * Nom/prenom de personne en Title Case (RG-3.11) : "JEAN dupont" -> + * "Jean Dupont". Une chaine vide apres trim devient null. + */ + public function normalizePersonName(?string $value): ?string + { + if (null === $value) { + return null; + } + + $value = trim($value); + + return '' === $value ? null : mb_convert_case($value, MB_CASE_TITLE, 'UTF-8'); + } + + /** + * Email en minuscules (RG-3.11). Une chaine vide apres trim devient null. + */ + public function normalizeEmail(?string $value): ?string + { + if (null === $value) { + return null; + } + + $value = trim($value); + + return '' === $value ? null : mb_strtolower($value, 'UTF-8'); + } + + /** + * Telephone reduit aux chiffres (RG-3.11) : "06.12.34.56.78" -> + * "0612345678". Une valeur sans aucun chiffre devient null. + */ + public function normalizePhone(?string $value): ?string + { + if (null === $value) { + return null; + } + + $digits = preg_replace('/\D+/', '', $value) ?? ''; + + return '' === $digits ? null : $digits; + } +} diff --git a/src/Module/Technique/Domain/Entity/Provider.php b/src/Module/Technique/Domain/Entity/Provider.php new file mode 100644 index 0000000..3b1da19 --- /dev/null +++ b/src/Module/Technique/Domain/Entity/Provider.php @@ -0,0 +1,563 @@ += 1). Nouveau vs supplier + * (qui n'avait des sites que sur l'adresse). Sert aussi le cloisonnement par + * site (§ 2.13, ticket Provider/Processor ERP-134). + * + * Referentiels comptables (TvaMode / PaymentDelay / PaymentType / Bank) et Site / + * Category : consommes en RELATION ORM PARTAGEE (decision Matthieu, § 2.1). Site / + * Category passent par les contrats Shared (SiteInterface / CategoryInterface + + * resolve_target_entities) comme le fait deja Supplier (regle ABSOLUE n°1). Les 4 + * referentiels comptables vivent dans le module Commercial et sont references en + * direct, faute de contrat Shared dedie (remontee dans Shared tracee HP-M4-2) — + * reference de donnees de reference, pas de logique inter-module. + * + * Contrat de serialisation (RETEX M1, 3 maillons — spec § 4.0) : les read-groups + * sont poses ICI (source unique). L'#[ApiResource] cable (ERP-134) le ProviderProvider + * (liste paginee anti-N+1, exclusion archives, cloisonnement site lecture + detail + * 404) et le ProviderProcessor (normalisation, archivage, mode strict par groupe, + * cloisonnement site ecriture, 409 doublon). Le groupe provider:read:accounting est + * ajoute dynamiquement au contexte par le ProviderReadGroupContextBuilder selon la + * permission accounting.view (ERP-134) — jamais pose en dur sur l'operation. + * + * Audite (#[Auditable], tous champs — y compris RIB embarques, § 2.7) + + * Timestampable / Blamable via le trait Shared. + */ +#[ApiResource( + operations: [ + new GetCollection( + security: "is_granted('technique.providers.view')", + // La liste embarque les categories (code/name, groupe category:read) et + // les sites du prestataire (name/postalCode, groupe site:read — relation + // DIRECTE provider.sites, RG-3.03). Maillon (c) : category:read + + // site:read presents dans le contexte. Hydratation anti-N+1 cablee par + // le ProviderProvider (cf. DoctrineProviderRepository::hydrateListCollections). + normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']], + provider: ProviderProvider::class, + ), + new Get( + security: "is_granted('technique.providers.view')", + // Detail : prestataire + sous-collections embarquees (contacts, adresses + // + leurs sites/categories/contacts) + RIB (gates compta). Le groupe + // provider:read:accounting est volontairement ABSENT : il est ajoute au + // contexte par le ProviderReadGroupContextBuilder selon la permission + // accounting.view (parade fuite IBAN/BIC — bug #4 M1). + normalizationContext: ['groups' => [ + 'provider:read', + 'provider:item:read', + 'category:read', + 'site:read', + 'default:read', + ]], + provider: ProviderProvider::class, + ), + new Post( + security: "is_granted('technique.providers.manage')", + normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']], + denormalizationContext: ['groups' => ['provider:write:main']], + processor: ProviderProcessor::class, + ), + new Patch( + // Security elargie : `manage` OU `accounting.manage` — le role Compta n'a + // pas `manage` global mais doit pouvoir editer l'onglet Comptabilite d'un + // prestataire existant (§ 2.9). Le re-gating onglet par onglet (mode strict + // RG-3.15) est porte par le ProviderProcessor (ERP-134). + security: "is_granted('technique.providers.manage') or is_granted('technique.providers.accounting.manage')", + normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']], + denormalizationContext: ['groups' => [ + 'provider:write:main', + 'provider:write:accounting', + 'provider:write:archive', + ]], + provider: ProviderProvider::class, + processor: ProviderProcessor::class, + ), + // Pas de Delete au M3 (HP M4). Archivage via PATCH { isArchived: true }. + ], +)] +#[ORM\Entity(repositoryClass: DoctrineProviderRepository::class)] +#[ORM\Table(name: 'provider')] +// Index nommes pour matcher la migration (Version20260612100000). L'index unique +// partiel uq_provider_company_name_active reste possede par la migration : Doctrine +// ORM ne sait pas exprimer un index fonctionnel (LOWER) + partiel (WHERE) via +// attribut. Pas de #[ORM\UniqueConstraint] (§ 2.6). +#[ORM\Index(name: 'idx_provider_is_archived', columns: ['is_archived'])] +#[ORM\Index(name: 'idx_provider_deleted_at', columns: ['deleted_at'])] +#[ORM\Index(name: 'idx_provider_created_by', columns: ['created_by'])] +#[ORM\Index(name: 'idx_provider_updated_by', columns: ['updated_by'])] +#[Auditable] +class Provider implements TimestampableInterface, BlamableInterface +{ + use TimestampableBlamableTrait; + + /** + * RG-3.09 : seules les categories PORTANT ce type sont autorisees sur le + * prestataire (entite principale) ET sur ses adresses. Miroir de + * ProviderAddress. S'appuie sur CategoryInterface::getCategoryTypeCodes() + * (pas d'import du module Catalog — regle ABSOLUE n°1). + */ + private const string REQUIRED_CATEGORY_TYPE_CODE = 'PRESTATAIRE'; + + #[ORM\Id] + #[ORM\GeneratedValue] + #[ORM\Column] + #[Groups(['provider:read'])] + private ?int $id = null; + + // === Formulaire principal === + #[ORM\Column(length: 180)] + #[Assert\NotBlank(message: 'Le nom du prestataire est obligatoire.', normalizer: 'trim')] + #[Assert\Length(min: 2, max: 180, minMessage: 'Le nom du prestataire doit comporter au moins {{ limit }} caractères.', maxMessage: 'Le nom du prestataire ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:read', 'provider:write:main'])] + private ?string $companyName = null; + + // RG-3.09 : au moins une categorie (Count min 1), de type PRESTATAIRE (verifie + // par validateCategoryType). M2M vers Category via le contrat CategoryInterface + // (resolve_target_entities -> Category). Embarquee en LISTE ET DETAIL ; maillon + // (c) : le contexte inclut 'category:read' pour exposer id/code/name. + /** @var Collection */ + #[ORM\ManyToMany(targetEntity: CategoryInterface::class)] + #[ORM\JoinTable(name: 'provider_category')] + #[ORM\JoinColumn(name: 'provider_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')] + #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')] + #[Groups(['provider:read', 'provider:write:main'])] + private Collection $categories; + + // RG-3.03 (SPECIFICITE M3) : au moins un site (Count min 1). Sites rattaches + // DIRECTEMENT au prestataire sur le formulaire principal (le fournisseur n'avait + // des sites que sur l'adresse). M2M vers Site via le contrat SiteInterface + // (resolve_target_entities -> Site). Embarquee en LISTE ET DETAIL ; maillon (c) : + // le contexte inclut 'site:read' pour exposer name/postalCode (Site n'a pas de + // `code`). L'ecriture cloisonnee par user_site (§ 2.13) est portee par le + // ProviderProcessor (ERP-134). + /** @var Collection */ + #[ORM\ManyToMany(targetEntity: SiteInterface::class)] + #[ORM\JoinTable(name: 'provider_site')] + #[ORM\JoinColumn(name: 'provider_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[ORM\InverseJoinColumn(name: 'site_id', referencedColumnName: 'id', onDelete: 'RESTRICT')] + #[Assert\Count(min: 1, minMessage: 'Au moins un site est obligatoire.')] + #[Groups(['provider:read', 'provider:write:main'])] + private Collection $sites; + + // === Onglet Comptabilite === + // Lecture conditionnee via le groupe `provider:read:accounting` (ajoute au + // contexte par le ProviderProvider / ReadGroupContextBuilder si l'user a + // accounting.view — ERP-134). Ecriture via `provider:write:accounting` (le + // Processor exige accounting.manage). + #[ORM\Column(length: 20, nullable: true)] + #[Assert\Length(max: 20, maxMessage: 'Le SIREN ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $siren = null; + + #[ORM\Column(length: 40, nullable: true)] + #[Assert\Length(max: 40, maxMessage: 'Le numéro de compte ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $accountNumber = null; + + #[ORM\ManyToOne(targetEntity: TvaMode::class)] + #[ORM\JoinColumn(name: 'tva_mode_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?TvaMode $tvaMode = null; + + #[ORM\Column(length: 40, nullable: true)] + #[Assert\Length(max: 40, maxMessage: 'Le numéro de TVA ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?string $nTva = null; + + #[ORM\ManyToOne(targetEntity: PaymentDelay::class)] + #[ORM\JoinColumn(name: 'payment_delay_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?PaymentDelay $paymentDelay = null; + + #[ORM\ManyToOne(targetEntity: PaymentType::class)] + #[ORM\JoinColumn(name: 'payment_type_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?PaymentType $paymentType = null; + + #[ORM\ManyToOne(targetEntity: Bank::class)] + #[ORM\JoinColumn(name: 'bank_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')] + #[Groups(['provider:read:accounting', 'provider:write:accounting'])] + private ?Bank $bank = null; + + // === Sous-collections — EMBARQUEES dans le DETAIL (RETEX M1 §2) === + // Maillon (a) : le read-group est porte par le GETTER (getContacts / getAddresses + // / getRibs) — sans #[Groups], jamais serialisees. Edition via sous-ressources + // (ticket ulterieur M3). + /** @var Collection */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + private Collection $contacts; + + /** @var Collection */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + private Collection $addresses; + + /** @var Collection */ + #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderRib::class, cascade: ['persist', 'remove'], orphanRemoval: true)] + private Collection $ribs; + + // === Archive / Soft delete === + // Groupe d'ECRITURE uniquement sur la propriete (denormalisation PATCH archive). + // Le groupe de LECTURE est declare sur le getter isArchived() avec + // SerializedName('isArchived') : sans cela, Symfony strip le prefixe "is" et + // exposerait la cle JSON "archived" — en pratique la cle est totalement DROPPEE + // (piege n°3 du M1). Pattern corrige : Groups + SerializedName sur le getter. + #[ORM\Column(name: 'is_archived', options: ['default' => false])] + #[Groups(['provider:write:archive'])] + private bool $isArchived = false; + + #[ORM\Column(type: 'datetime_immutable', nullable: true)] + #[Groups(['provider:read'])] + private ?DateTimeImmutable $archivedAt = null; + + // Soft delete technique (HP M4) : non expose en lecture/ecriture au M3. + #[ORM\Column(type: 'datetime_immutable', nullable: true)] + private ?DateTimeImmutable $deletedAt = null; + + public function __construct() + { + $this->categories = new ArrayCollection(); + $this->sites = new ArrayCollection(); + $this->contacts = new ArrayCollection(); + $this->addresses = new ArrayCollection(); + $this->ribs = new ArrayCollection(); + } + + /** + * RG-3.09 : toute categorie posee sur le prestataire doit etre de type + * PRESTATAIRE -> sinon 422 avec violation sur le champ `categories` + * (propertyPath aligne ERP-101, message FR ERP-107). Miroir de + * ProviderAddress::validateCategoryType. S'appuie sur + * CategoryInterface::getCategoryTypeCodes() (multi-type — la categorie est + * acceptee des qu'elle PORTE le type PRESTATAIRE ; pas d'import du module + * Catalog, regle ABSOLUE n°1). Joue avant la base via la validation API + * Platform, sur POST (categories ∈ provider:write:main) comme sur PATCH. + */ + #[Assert\Callback] + public function validateCategoryType(ExecutionContextInterface $context): void + { + foreach ($this->categories as $category) { + if ($category instanceof CategoryInterface + && !in_array(self::REQUIRED_CATEGORY_TYPE_CODE, $category->getCategoryTypeCodes(), true)) { + $context->buildViolation('Type de catégorie non autorisé (PRESTATAIRE attendu).') + ->atPath('categories') + ->addViolation() + ; + + return; + } + } + } + + public function getId(): ?int + { + return $this->id; + } + + public function getCompanyName(): ?string + { + return $this->companyName; + } + + public function setCompanyName(string $companyName): static + { + $this->companyName = $companyName; + + return $this; + } + + /** @return Collection */ + public function getCategories(): Collection + { + return $this->categories; + } + + public function addCategory(CategoryInterface $category): static + { + if (!$this->categories->contains($category)) { + $this->categories->add($category); + } + + return $this; + } + + public function removeCategory(CategoryInterface $category): static + { + $this->categories->removeElement($category); + + return $this; + } + + /** @return Collection */ + public function getSites(): Collection + { + return $this->sites; + } + + public function addSite(SiteInterface $site): static + { + if (!$this->sites->contains($site)) { + $this->sites->add($site); + } + + return $this; + } + + public function removeSite(SiteInterface $site): static + { + $this->sites->removeElement($site); + + return $this; + } + + public function getSiren(): ?string + { + return $this->siren; + } + + public function setSiren(?string $siren): static + { + $this->siren = $siren; + + return $this; + } + + public function getAccountNumber(): ?string + { + return $this->accountNumber; + } + + public function setAccountNumber(?string $accountNumber): static + { + $this->accountNumber = $accountNumber; + + return $this; + } + + public function getTvaMode(): ?TvaMode + { + return $this->tvaMode; + } + + public function setTvaMode(?TvaMode $tvaMode): static + { + $this->tvaMode = $tvaMode; + + return $this; + } + + public function getNTva(): ?string + { + return $this->nTva; + } + + public function setNTva(?string $nTva): static + { + $this->nTva = $nTva; + + return $this; + } + + public function getPaymentDelay(): ?PaymentDelay + { + return $this->paymentDelay; + } + + public function setPaymentDelay(?PaymentDelay $paymentDelay): static + { + $this->paymentDelay = $paymentDelay; + + return $this; + } + + public function getPaymentType(): ?PaymentType + { + return $this->paymentType; + } + + public function setPaymentType(?PaymentType $paymentType): static + { + $this->paymentType = $paymentType; + + return $this; + } + + public function getBank(): ?Bank + { + return $this->bank; + } + + public function setBank(?Bank $bank): static + { + $this->bank = $bank; + + return $this; + } + + /** @return Collection */ + #[Groups(['provider:item:read'])] + public function getContacts(): Collection + { + return $this->contacts; + } + + public function addContact(ProviderContact $contact): static + { + if (!$this->contacts->contains($contact)) { + $this->contacts->add($contact); + $contact->setProvider($this); + } + + return $this; + } + + public function removeContact(ProviderContact $contact): static + { + if ($this->contacts->removeElement($contact) && $contact->getProvider() === $this) { + $contact->setProvider(null); + } + + return $this; + } + + /** @return Collection */ + #[Groups(['provider:item:read'])] + public function getAddresses(): Collection + { + return $this->addresses; + } + + public function addAddress(ProviderAddress $address): static + { + if (!$this->addresses->contains($address)) { + $this->addresses->add($address); + $address->setProvider($this); + } + + return $this; + } + + public function removeAddress(ProviderAddress $address): static + { + if ($this->addresses->removeElement($address) && $address->getProvider() === $this) { + $address->setProvider(null); + } + + return $this; + } + + // Embed gate sur le groupe COMPTABLE (et non provider:item:read comme contacts/ + // adresses) : provider:read:accounting n'est ajoute au contexte que si l'user a + // accounting.view (ProviderProvider / ReadGroupContextBuilder, ERP-134). Resultat : + // la cle `ribs` est TOTALEMENT ABSENTE du detail pour un user sans accounting.view + // (ex. Commerciale), au meme titre que les scalaires comptables — evite la fuite + // IBAN/BIC (piege n°4 M1). + /** @return Collection */ + #[Groups(['provider:read:accounting'])] + public function getRibs(): Collection + { + return $this->ribs; + } + + public function addRib(ProviderRib $rib): static + { + if (!$this->ribs->contains($rib)) { + $this->ribs->add($rib); + $rib->setProvider($this); + } + + return $this; + } + + public function removeRib(ProviderRib $rib): static + { + if ($this->ribs->removeElement($rib) && $rib->getProvider() === $this) { + $rib->setProvider(null); + } + + return $this; + } + + // Groupe de lecture + nom serialise explicite : sans SerializedName, Symfony + // exposerait la cle "archived" (strip du prefixe "is" sur les getters) et + // droppait silencieusement la cle du JSON (piege n°3 du M1). + #[Groups(['provider:read'])] + #[SerializedName('isArchived')] + public function isArchived(): bool + { + return $this->isArchived; + } + + public function setIsArchived(bool $isArchived): static + { + $this->isArchived = $isArchived; + + return $this; + } + + public function getArchivedAt(): ?DateTimeImmutable + { + return $this->archivedAt; + } + + public function setArchivedAt(?DateTimeImmutable $archivedAt): static + { + $this->archivedAt = $archivedAt; + + return $this; + } + + public function getDeletedAt(): ?DateTimeImmutable + { + return $this->deletedAt; + } + + public function setDeletedAt(?DateTimeImmutable $deletedAt): static + { + $this->deletedAt = $deletedAt; + + return $this; + } +} diff --git a/src/Module/Technique/Domain/Entity/ProviderAddress.php b/src/Module/Technique/Domain/Entity/ProviderAddress.php new file mode 100644 index 0000000..4b26a5d --- /dev/null +++ b/src/Module/Technique/Domain/Entity/ProviderAddress.php @@ -0,0 +1,314 @@ + 'France'])] + #[Assert\Length(max: 80, maxMessage: 'Le pays ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private string $country = 'France'; + + // RG-3.06 : code postal a 4 ou 5 chiffres (pas de controle CP/ville serveur). + // Le Regex borne deja la longueur (<= 5) : pas de Length redondant (whitelist + // ERP-107). + #[ORM\Column(length: 20)] + #[Assert\NotBlank(message: 'Le code postal est obligatoire.', normalizer: 'trim')] + #[Assert\Regex(pattern: '/^[0-9]{4,5}$/', message: 'Le code postal doit comporter 4 ou 5 chiffres.')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private ?string $postalCode = null; + + #[ORM\Column(length: 120)] + #[Assert\NotBlank(message: 'La ville est obligatoire.', normalizer: 'trim')] + #[Assert\Length(max: 120, maxMessage: 'La ville ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private ?string $city = null; + + #[ORM\Column(length: 255)] + #[Assert\NotBlank(message: 'La rue est obligatoire.', normalizer: 'trim')] + #[Assert\Length(max: 255, maxMessage: 'La rue ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private ?string $street = null; + + #[ORM\Column(length: 255, nullable: true)] + #[Assert\Length(max: 255, maxMessage: 'Le complément d\'adresse ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private ?string $streetComplement = null; + + // Ordre d'affichage de l'adresse (gere serveur, non expose au M3). + #[ORM\Column(options: ['default' => 0])] + private int $position = 0; + + // RG-3.05 : au moins un site rattache a chaque adresse. + /** @var Collection */ + #[ORM\ManyToMany(targetEntity: SiteInterface::class)] + #[ORM\JoinTable(name: 'provider_address_site')] + #[ORM\JoinColumn(name: 'provider_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[ORM\InverseJoinColumn(name: 'site_id', referencedColumnName: 'id', onDelete: 'RESTRICT')] + #[Assert\Count(min: 1, minMessage: 'Au moins un site est obligatoire.')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private Collection $sites; + + /** @var Collection */ + #[ORM\ManyToMany(targetEntity: ProviderContact::class)] + #[ORM\JoinTable(name: 'provider_address_contact')] + #[ORM\JoinColumn(name: 'provider_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[ORM\InverseJoinColumn(name: 'provider_contact_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private Collection $contacts; + + // RG-3.09 : au moins une categorie de type PRESTATAIRE par adresse (le type est + // controle par validateCategoryType ; le minimum par Assert\Count, miroir sites). + /** @var Collection */ + #[ORM\ManyToMany(targetEntity: CategoryInterface::class)] + #[ORM\JoinTable(name: 'provider_address_category')] + #[ORM\JoinColumn(name: 'provider_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')] + #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')] + #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')] + #[Groups(['provider:item:read', 'provider:write:addresses'])] + private Collection $categories; + + public function __construct() + { + $this->sites = new ArrayCollection(); + $this->contacts = new ArrayCollection(); + $this->categories = new ArrayCollection(); + } + + /** + * RG-3.09 : toute categorie posee sur une adresse prestataire doit etre de + * type PRESTATAIRE -> sinon 422 avec violation sur le champ `categories` + * (propertyPath aligne ERP-101, message FR ERP-107). S'appuie sur + * CategoryInterface::getCategoryTypeCodes() (multi-type — la categorie est + * acceptee des qu'elle PORTE le type PRESTATAIRE ; pas d'import du module + * Catalog, regle ABSOLUE n°1). Joue avant la base via la validation API Platform. + */ + #[Assert\Callback] + public function validateCategoryType(ExecutionContextInterface $context): void + { + foreach ($this->categories as $category) { + if ($category instanceof CategoryInterface + && !in_array(self::REQUIRED_CATEGORY_TYPE_CODE, $category->getCategoryTypeCodes(), true)) { + $context->buildViolation('Type de catégorie non autorisé (PRESTATAIRE attendu).') + ->atPath('categories') + ->addViolation() + ; + + return; + } + } + } + + public function getId(): ?int + { + return $this->id; + } + + public function getProvider(): ?Provider + { + return $this->provider; + } + + public function setProvider(?Provider $provider): static + { + $this->provider = $provider; + + return $this; + } + + public function getCountry(): string + { + return $this->country; + } + + public function setCountry(string $country): static + { + $this->country = $country; + + return $this; + } + + public function getPostalCode(): ?string + { + return $this->postalCode; + } + + public function setPostalCode(?string $postalCode): static + { + $this->postalCode = $postalCode; + + return $this; + } + + public function getCity(): ?string + { + return $this->city; + } + + public function setCity(?string $city): static + { + $this->city = $city; + + return $this; + } + + public function getStreet(): ?string + { + return $this->street; + } + + public function setStreet(?string $street): static + { + $this->street = $street; + + return $this; + } + + public function getStreetComplement(): ?string + { + return $this->streetComplement; + } + + public function setStreetComplement(?string $streetComplement): static + { + $this->streetComplement = $streetComplement; + + return $this; + } + + public function getPosition(): int + { + return $this->position; + } + + public function setPosition(int $position): static + { + $this->position = $position; + + return $this; + } + + /** @return Collection */ + public function getSites(): Collection + { + return $this->sites; + } + + public function addSite(SiteInterface $site): static + { + if (!$this->sites->contains($site)) { + $this->sites->add($site); + } + + return $this; + } + + public function removeSite(SiteInterface $site): static + { + $this->sites->removeElement($site); + + return $this; + } + + /** @return Collection */ + public function getContacts(): Collection + { + return $this->contacts; + } + + public function addContact(ProviderContact $contact): static + { + if (!$this->contacts->contains($contact)) { + $this->contacts->add($contact); + } + + return $this; + } + + public function removeContact(ProviderContact $contact): static + { + $this->contacts->removeElement($contact); + + return $this; + } + + /** @return Collection */ + public function getCategories(): Collection + { + return $this->categories; + } + + public function addCategory(CategoryInterface $category): static + { + if (!$this->categories->contains($category)) { + $this->categories->add($category); + } + + return $this; + } + + public function removeCategory(CategoryInterface $category): static + { + $this->categories->removeElement($category); + + return $this; + } +} diff --git a/src/Module/Technique/Domain/Entity/ProviderContact.php b/src/Module/Technique/Domain/Entity/ProviderContact.php new file mode 100644 index 0000000..9abe03e --- /dev/null +++ b/src/Module/Technique/Domain/Entity/ProviderContact.php @@ -0,0 +1,189 @@ + 0])] + private int $position = 0; + + public function getId(): ?int + { + return $this->id; + } + + public function getProvider(): ?Provider + { + return $this->provider; + } + + public function setProvider(?Provider $provider): static + { + $this->provider = $provider; + + return $this; + } + + public function getFirstName(): ?string + { + return $this->firstName; + } + + public function setFirstName(?string $firstName): static + { + $this->firstName = $firstName; + + return $this; + } + + public function getLastName(): ?string + { + return $this->lastName; + } + + public function setLastName(?string $lastName): static + { + $this->lastName = $lastName; + + return $this; + } + + public function getJobTitle(): ?string + { + return $this->jobTitle; + } + + public function setJobTitle(?string $jobTitle): static + { + $this->jobTitle = $jobTitle; + + return $this; + } + + public function getPhonePrimary(): ?string + { + return $this->phonePrimary; + } + + public function setPhonePrimary(?string $phonePrimary): static + { + $this->phonePrimary = $phonePrimary; + + return $this; + } + + public function getPhoneSecondary(): ?string + { + return $this->phoneSecondary; + } + + public function setPhoneSecondary(?string $phoneSecondary): static + { + $this->phoneSecondary = $phoneSecondary; + + return $this; + } + + public function getEmail(): ?string + { + return $this->email; + } + + public function setEmail(?string $email): static + { + $this->email = $email; + + return $this; + } + + public function getPosition(): int + { + return $this->position; + } + + public function setPosition(int $position): static + { + $this->position = $position; + + return $this; + } +} diff --git a/src/Module/Technique/Domain/Entity/ProviderRib.php b/src/Module/Technique/Domain/Entity/ProviderRib.php new file mode 100644 index 0000000..c400c67 --- /dev/null +++ b/src/Module/Technique/Domain/Entity/ProviderRib.php @@ -0,0 +1,146 @@ + 0])] + private int $position = 0; + + public function getId(): ?int + { + return $this->id; + } + + public function getProvider(): ?Provider + { + return $this->provider; + } + + public function setProvider(?Provider $provider): static + { + $this->provider = $provider; + + return $this; + } + + public function getLabel(): ?string + { + return $this->label; + } + + public function setLabel(string $label): static + { + $this->label = $label; + + return $this; + } + + public function getBic(): ?string + { + return $this->bic; + } + + public function setBic(string $bic): static + { + $this->bic = $bic; + + return $this; + } + + public function getIban(): ?string + { + return $this->iban; + } + + public function setIban(string $iban): static + { + $this->iban = $iban; + + return $this; + } + + public function getPosition(): int + { + return $this->position; + } + + public function setPosition(int $position): static + { + $this->position = $position; + + return $this; + } +} diff --git a/src/Module/Technique/Domain/Repository/ProviderRepositoryInterface.php b/src/Module/Technique/Domain/Repository/ProviderRepositoryInterface.php new file mode 100644 index 0000000..49f5fb1 --- /dev/null +++ b/src/Module/Technique/Domain/Repository/ProviderRepositoryInterface.php @@ -0,0 +1,98 @@ + uniquement les archives (is_archived = true) ; + * - sinon $includeArchived = true -> actifs + archives (echappatoire) ; + * - sinon (defaut) -> uniquement les actifs (is_archived = false). + * $archivedOnly a la priorite sur $includeArchived. + * - Tri par defaut : companyName ASC (RG-3.16). + * - $search : recherche fuzzy insensible a la casse sur companyName + les + * contacts lies (firstName / lastName / email) via sous-requete. + * Metacaracteres LIKE echappes. Ignore si null/vide. + * - $categoryCodes : restreint aux prestataires possedant au moins une + * categorie dont le code est dans la liste (OR). Liste vide = pas de filtre. + * - $siteIds : restreint aux prestataires rattaches a l'un des sites donnes + * (OR — RG-3.03, relation DIRECTE provider.sites). Liste vide = pas de filtre. + * + * Filtrage centralise ICI (et non dans le provider/controller) pour que la + * liste paginee et l'export partagent strictement la meme logique de selection + * (miroir M2). + * + * Contrat = SELECTION uniquement (filtres + tri). Aucun fetch-join to-many : + * l'hydratation des collections affichees est deleguee a + * {@see self::hydrateListCollections()} pour ne pas imposer le cout d'un + * produit cartesien aux chemins non pagines (§ 2.12, cf. M1/ERP-100, M2). + * + * NB : le cloisonnement par site pilote par l'utilisateur (RG-3.17, § 2.13) est + * applique en AMONT par le ProviderProvider (ERP-134), pas par ce QueryBuilder + * (qui ne connait pas l'user courant). + * + * @param list $categoryCodes + * @param list $siteIds + */ + public function createListQueryBuilder( + bool $includeArchived = false, + ?string $search = null, + array $categoryCodes = [], + array $siteIds = [], + bool $archivedOnly = false, + ): QueryBuilder; + + /** + * Hydrate en lot les collections affichees par le repertoire (categories puis + * sites — relation DIRECTE provider.sites, RG-3.03) sur un jeu de prestataires + * DEJA charges, via l'identity map Doctrine (memes instances). A appeler apres + * une selection bornee (page courante ou jeu d'export) pour eviter le N+1 a la + * serialisation, sans imposer de fetch-join au QueryBuilder de selection + * (anti N+1, § 2.12). + * + * Charge les categories et les sites en DEUX requetes distinctes (et non un + * double fetch-join) pour ne pas multiplier categories x sites en un seul + * produit cartesien. + * + * @param list $providers + */ + public function hydrateListCollections(array $providers): void; + + /** + * Hydrate en lot la collection `contacts` sur un jeu de prestataires DEJA + * charges (memes instances via l'identity map). Reservee aux chemins qui ont + * besoin du contact principal (export) : la LISTE paginee n'embarque pas les + * contacts (§ 2.12), d'ou une methode dediee plutot qu'une passe supplementaire + * dans {@see self::hydrateListCollections()}. + * + * @param list $providers + */ + public function hydrateContacts(array $providers): void; +} diff --git a/src/Module/Technique/Infrastructure/ApiPlatform/Serializer/ProviderReadGroupContextBuilder.php b/src/Module/Technique/Infrastructure/ApiPlatform/Serializer/ProviderReadGroupContextBuilder.php new file mode 100644 index 0000000..0ba501f --- /dev/null +++ b/src/Module/Technique/Infrastructure/ApiPlatform/Serializer/ProviderReadGroupContextBuilder.php @@ -0,0 +1,76 @@ +decorated->createFromRequest($request, $normalization, $extractedAttributes); + + // Uniquement en lecture, sur la ressource Provider, avec la permission. + if (!$normalization) { + return $context; + } + + if (Provider::class !== ($context['resource_class'] ?? null)) { + return $context; + } + + if (!$this->security->isGranted('technique.providers.accounting.view')) { + return $context; + } + + $groups = $context['groups'] ?? []; + if (!in_array('provider:read:accounting', $groups, true)) { + $groups[] = 'provider:read:accounting'; + } + $context['groups'] = $groups; + + return $context; + } +} diff --git a/src/Module/Technique/Infrastructure/ApiPlatform/State/Processor/ProviderProcessor.php b/src/Module/Technique/Infrastructure/ApiPlatform/State/Processor/ProviderProcessor.php new file mode 100644 index 0000000..a439a13 --- /dev/null +++ b/src/Module/Technique/Infrastructure/ApiPlatform/State/Processor/ProviderProcessor.php @@ -0,0 +1,559 @@ + le prestataire est minimal ; + * - le formulaire principal porte `sites` (M2M provider_site, RG-3.03), soumis au + * CLOISONNEMENT D'ECRITURE par site (RG-3.17, § 2.13) : un user sans + * `sites.bypass_scope` ne peut attacher que les sites de ses `user_site`. + * + * Sequence (POST / PATCH) : + * 1. Autorisation additionnelle par groupe d'onglet (mode strict RG-3.15). La + * security d'operation du PATCH est elargie a `manage` OU `accounting.manage` + * pour laisser entrer le role Compta ; ce processor re-gate alors finement : + * - champ comptable modifie dans le payload -> exige accounting.manage (403) ; + * - champ main (companyName / categories / sites) modifie -> exige manage + * (guardManage, 403) : empeche Compta d'editer un autre onglet ; + * - champ isArchived dans le payload -> exige archive (RG-3.13, 403) et + * interdit toute autre modification dans la meme requete (RG-3.13, 422). + * 2. Cloisonnement d'ECRITURE des sites (RG-3.17 / RG-3.03) : tout site attache + * hors des `user_site` de l'appelant non-bypass -> 422 sur `sites`. + * 3. Normalisation serveur (RG-3.11) via ProviderFieldNormalizer (companyName). + * 4. Pose / retrait de archivedAt (RG-3.13 true=now, RG-3.14 false=null). + * 5. Persistance via le persist_processor Doctrine, avec traduction des + * collisions d'unicite en 409 (RG-3.10 doublon de nom ; RG-3.14 conflit de + * restauration). + * + * La RG-3.09 (categorie de type PRESTATAIRE) est portee par un Assert\Callback + + * ->atPath() sur l'entite Provider (joue par API Platform AVANT ce processor), + * pour que la 422 porte un propertyPath consommable par extractApiViolations + * (mapping inline, pas un toast — convention ERP-101). Les RG-3.07 (Virement -> + * banque) et RG-3.08 (LCR -> RIB) relevent de l'onglet Comptabilite / sous-ressource + * RIB (ticket dedie) et ne sont pas portees ici. + * + * @implements ProcessorInterface + */ +final class ProviderProcessor implements ProcessorInterface +{ + /** Champs de l'onglet principal (groupe provider:write:main). */ + private const array MAIN_FIELDS = [ + 'companyName', 'categories', 'sites', + ]; + + /** Champs de l'onglet Comptabilite (groupe provider:write:accounting). */ + private const array ACCOUNTING_FIELDS = [ + 'siren', 'accountNumber', 'tvaMode', 'nTva', 'paymentDelay', + 'paymentType', 'bank', + ]; + + /** Champ d'archivage (groupe provider:write:archive). */ + private const string ARCHIVE_FIELD = 'isArchived'; + + private const string PERM_MANAGE = 'technique.providers.manage'; + private const string PERM_ACCOUNTING_MANAGE = 'technique.providers.accounting.manage'; + private const string PERM_ARCHIVE = 'technique.providers.archive'; + + private const string PERM_BYPASS_SCOPE = 'sites.bypass_scope'; + + /** + * Memoisation du dernier corps de requete decode, clos par le contenu brut + * (cf. SupplierProcessor) : payloadKeys() est appele plusieurs fois par requete, + * on evite de rejouer json_decode. Cle = contenu lui-meme, calcul pur -> aucune + * fuite entre requetes sur ce service partage. + */ + private ?string $decodedContent = null; + + /** @var list Cles de premier niveau correspondant au corps memoise. */ + private array $decodedPayloadKeys = []; + + public function __construct( + #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')] + private readonly ProcessorInterface $persistProcessor, + private readonly ProviderFieldNormalizer $normalizer, + private readonly Security $security, + private readonly RequestStack $requestStack, + private readonly EntityManagerInterface $em, + ) {} + + public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed + { + if (!$data instanceof Provider) { + return $this->persistProcessor->process($data, $operation, $uriVariables, $context); + } + + // Reinitialisation de la memoisation du payload : le service est partage + // (stateful), on repart du corps de LA requete courante. + $this->decodedContent = null; + $this->decodedPayloadKeys = []; + + $writableKeys = $this->writablePayloadKeys(); + + $isArchiveRequest = $this->guardArchive($data, $writableKeys); + $this->guardAccounting($data); + $this->guardSiteScope($data); + + $this->normalize($data); + + // guardManage apres normalize : la comparaison « change vs etat persiste » + // des champs texte (companyName) se fait sur des valeurs normalisees des + // deux cotes (l'etat persiste l'a deja ete). + $this->guardManage($data); + + try { + return $this->persistProcessor->process($data, $operation, $uriVariables, $context); + } catch (UniqueConstraintViolationException $e) { + // Le seul index unique partiel est uq_provider_company_name_active + // (LOWER(company_name) parmi non-archives/non-deletes — § 2.6). + if ($isArchiveRequest && false === $data->isArchived()) { + // RG-3.14 : restauration en conflit avec un homonyme actif. + throw new ConflictHttpException( + 'Restauration impossible : un autre prestataire a pris le nom entre-temps.', + $e, + ); + } + + // RG-3.10 : doublon de nom de societe. + throw new ConflictHttpException( + sprintf('Un prestataire nommé "%s" existe déjà.', (string) $data->getCompanyName()), + $e, + ); + } + } + + /** + * RG-3.13 / RG-3.14 : si le payload bascule reellement isArchived, exige la + * permission archive (403), interdit toute autre modification (422) et + * pose/retire archivedAt. Retourne true si la requete est une requete + * d'archivage. Restreint a la mise a jour d'un prestataire existant ET au seul + * cas ou isArchived change vraiment (cf. SupplierProcessor). + * + * @param list $writableKeys cles ecrivables du payload (hors @* et champs inconnus) + */ + private function guardArchive(Provider $data, array $writableKeys): bool + { + // POST / entite non geree : l'archivage est une action de mise a jour. + if (!$this->em->contains($data)) { + return false; + } + + // isArchived inchange par rapport a l'etat persiste : pas une requete + // d'archivage (cas du PATCH representation complete). + if (!$this->fieldChanged($data, 'isArchived', $data->isArchived())) { + return false; + } + + if (!$this->security->isGranted(self::PERM_ARCHIVE)) { + throw new AccessDeniedHttpException(sprintf( + 'Le champ "%s" requiert la permission "%s".', + self::ARCHIVE_FIELD, + self::PERM_ARCHIVE, + )); + } + + // RG-3.13 : une requete d'archivage ne modifie aucun autre champ ecrivable. + if ([] !== array_diff($writableKeys, [self::ARCHIVE_FIELD])) { + throw new UnprocessableEntityHttpException( + 'Une requête d\'archivage ne peut modifier aucun autre champ que "isArchived".', + ); + } + + // RG-3.13 (true -> now) / RG-3.14 (false -> null). + $data->setArchivedAt($data->isArchived() ? new DateTimeImmutable() : null); + + return true; + } + + /** + * RG-3.15 : la modification effective d'un champ comptable exige + * accounting.manage, sinon 403 sur l'ensemble du payload (mode strict, pas de + * filtrage silencieux). On ne gate que si un champ change reellement par + * rapport a l'etat persiste (POST/PATCH renvoyant des champs comptables + * inchanges ne declenche pas de 403 parasite). Le message precise le premier + * champ fautif. + */ + private function guardAccounting(Provider $data): void + { + $changed = $this->changedAccountingFields($data); + + if ([] === $changed) { + return; + } + + if (!$this->security->isGranted(self::PERM_ACCOUNTING_MANAGE)) { + throw new AccessDeniedHttpException(sprintf( + 'Le champ "%s" requiert la permission "%s".', + $changed[0], + self::PERM_ACCOUNTING_MANAGE, + )); + } + } + + /** + * § 2.9 / RG-3.15 : la modification effective d'un champ « metier » (onglet + * principal : companyName / categories / sites) exige + * `technique.providers.manage`. Sans cette permission -> 403 sur l'ensemble du + * payload (mode strict, miroir de guardAccounting). C'est ce qui empeche le + * role Compta — qui entre dans le PATCH via `accounting.manage` (security + * d'operation elargie) — d'editer autre chose que l'onglet Comptabilite. + * + * Ne s'applique qu'aux mises a jour (entite geree) : la creation (POST) est + * deja gardee par la security d'operation `manage`. + */ + private function guardManage(Provider $data): void + { + if (!$this->em->contains($data)) { + return; + } + + $changed = $this->changedBusinessFields($data); + + if ([] === $changed) { + return; + } + + if (!$this->security->isGranted(self::PERM_MANAGE)) { + throw new AccessDeniedHttpException(sprintf( + 'Le champ "%s" requiert la permission "%s".', + $changed[0], + self::PERM_MANAGE, + )); + } + } + + /** + * RG-3.17 / RG-3.03 (cloisonnement d'ECRITURE — § 2.13) : un user SANS + * `sites.bypass_scope` ne peut attacher au prestataire que des sites figurant + * dans ses propres `user_site`. Tout site hors perimetre -> 422 sur `sites` + * (propertyPath consommable inline, convention ERP-101). Un user `bypass_scope` + * (Admin auto) peut attacher n'importe quel site. + * + * Interaction avec SiteCollectionScopedExtension (module Sites) : pour un user + * sans `sites.bypass_scope` NI `sites.read_ref`, la resolution de l'IRI de site + * hors perimetre echoue DEJA en amont (item Site « introuvable » -> 400 + * anti-enumeration), avant ce processor. Cette garde reste donc l'enforcement + * AUTORITAIRE de RG-3.17 pour le cas particulier d'un user `sites.read_ref` + * (qui peut resoudre N'IMPORTE quel site comme referentiel transverse mais ne + * doit rattacher que ses propres sites), et une defense en profondeur sinon. + * + * Ne joue que si `sites` est effectivement soumis : POST (entite non geree, + * sites obligatoires RG-3.03) ou PATCH portant la cle `sites`. Un PATCH qui ne + * touche pas aux sites n'est pas re-valide (les sites ont ete cloisonnes a leur + * pose). La validation porte sur l'ETAT RESULTANT (data.getSites()). + */ + private function guardSiteScope(Provider $data): void + { + if ($this->security->isGranted(self::PERM_BYPASS_SCOPE)) { + return; + } + + // sites non soumis sur un PATCH : rien a cloisonner. + if ($this->em->contains($data) && !in_array('sites', $this->payloadKeys(), true)) { + return; + } + + $allowedSiteIds = $this->currentUserSiteIds(); + + foreach ($data->getSites() as $site) { + if (!$site instanceof SiteInterface) { + continue; + } + if (!in_array($site->getId(), $allowedSiteIds, true)) { + $this->throwSitesViolation($data); + } + } + } + + /** + * Identifiants des sites rattaches a l'utilisateur courant (`user_site`). + * Vide si pas d'user authentifie (cas defensif : la security d'operation + * garantit deja l'authentification). + * + * @return list + */ + private function currentUserSiteIds(): array + { + $user = $this->security->getUser(); + if (!$user instanceof User) { + return []; + } + + $ids = []; + foreach ($user->getSites() as $site) { + if ($site instanceof SiteInterface && null !== $site->getId()) { + $ids[] = $site->getId(); + } + } + + return $ids; + } + + /** + * Champs « metier » (onglet principal : companyName / categories / sites) dont + * la valeur courante differe de l'etat persiste. Scalaires compares par valeur ; + * collections M2M (categories / sites) comparees par ensemble d'identifiants + * (cf. collectionChanged) — la simple presence dans le payload ne suffit pas, + * sous peine de 403 parasite sur un PATCH representation complete. + * + * @return list + */ + private function changedBusinessFields(Provider $data): array + { + $changed = []; + + if ($this->fieldChanged($data, 'companyName', $data->getCompanyName())) { + $changed[] = 'companyName'; + } + + if ($this->collectionChanged($data, 'categories', $data->getCategories()->toArray())) { + $changed[] = 'categories'; + } + + if ($this->collectionChanged($data, 'sites', $data->getSites()->toArray())) { + $changed[] = 'sites'; + } + + return $changed; + } + + /** + * Vrai si une collection M2M (`categories` ou `sites`) differe reellement de + * l'etat persiste. Ces collections ne sont pas tracees par + * getOriginalEntityData : on compare par identifiants (independamment de + * l'ordre) le snapshot de la PersistentCollection (etat charge) a l'etat + * courant (apres application du payload). Symetrique des scalaires : seul un + * changement effectif compte, pas la simple presence dans le payload. + * + * - POST / entite non geree : fournir la collection est un acte metier + * (branche defensive, guardManage ne s'execute que sur entite geree). + * - cle absente du payload (PATCH partiel) : aucun changement. + * + * @param array $current + */ + private function collectionChanged(Provider $data, string $field, array $current): bool + { + if (!$this->em->contains($data)) { + return true; + } + + if (!in_array($field, $this->payloadKeys(), true)) { + return false; + } + + $collection = 'categories' === $field ? $data->getCategories() : $data->getSites(); + + // Hors PersistentCollection (cas limite hors flux PATCH reel) : faute d'etat + // persiste comparable, on se rabat sur la presence payload. + if (!$collection instanceof PersistentCollection) { + return true; + } + + return $this->idSet($current) !== $this->idSet($collection->getSnapshot()); + } + + /** + * Ensemble trie des identifiants d'une liste d'entites — pour une comparaison + * par valeur independante de l'ordre. + * + * @param array $entities + * + * @return list + */ + private function idSet(array $entities): array + { + $ids = array_map( + static fn (object $entity): mixed => method_exists($entity, 'getId') + ? $entity->getId() + : spl_object_id($entity), + array_values($entities), + ); + sort($ids); + + return $ids; + } + + /** + * Champs comptables dont la valeur courante differe de l'etat persiste. Les + * relations (tvaMode, paymentDelay, paymentType, bank) sont comparees par + * identite d'objet : l'identity map Doctrine renvoie la meme instance tant que + * la reference est inchangee. + * + * @return list + */ + private function changedAccountingFields(Provider $data): array + { + $changed = []; + + foreach (self::ACCOUNTING_FIELDS as $field) { + $newValue = match ($field) { + 'siren' => $data->getSiren(), + 'accountNumber' => $data->getAccountNumber(), + 'tvaMode' => $data->getTvaMode(), + 'nTva' => $data->getNTva(), + 'paymentDelay' => $data->getPaymentDelay(), + 'paymentType' => $data->getPaymentType(), + 'bank' => $data->getBank(), + }; + + if ($this->fieldChanged($data, $field, $newValue)) { + $changed[] = $field; + } + } + + return $changed; + } + + /** + * Vrai si la valeur courante d'un champ differe de l'etat persiste. Pour une + * entite non geree (creation/POST), l'etat persiste est vide : toute valeur + * non-null est alors un changement. + */ + private function fieldChanged(Provider $data, string $field, mixed $newValue): bool + { + $original = $this->originalData($data); + + return $newValue !== ($original[$field] ?? null); + } + + /** + * Snapshot des valeurs persistees de l'entite (telles que chargees, avant + * application du payload). Vide pour une entite non geree (POST). + * + * @return array + */ + private function originalData(Provider $data): array + { + if (!$this->em->contains($data)) { + return []; + } + + return $this->em->getUnitOfWork()->getOriginalEntityData($data); + } + + /** + * Normalisation serveur du formulaire principal (RG-3.11). Seul companyName est + * porte par le Provider (les champs de contact sont normalises par le processor + * de sous-ressource ProviderContact, ticket dedie). Le setter non-nullable n'est + * touche que si une valeur est presente, pour ne jamais ecraser l'existant lors + * d'un PATCH partiel. + */ + private function normalize(Provider $data): void + { + if (null !== $data->getCompanyName()) { + $data->setCompanyName((string) $this->normalizer->normalizeCompanyName($data->getCompanyName())); + } + } + + /** + * Cles ecrivables effectivement presentes dans le payload : on retire les cles + * JSON-LD (@id, @context...) et tout champ non rattache a un groupe d'ecriture + * connu. Base du 422 d'archivage (RG-3.13). + * + * @return list + */ + private function writablePayloadKeys(): array + { + $writable = array_merge( + self::MAIN_FIELDS, + self::ACCOUNTING_FIELDS, + [self::ARCHIVE_FIELD], + ); + + return array_values(array_intersect($this->payloadKeys(), $writable)); + } + + /** + * Cles de premier niveau effectivement envoyees par le client (payload JSON + * brut). Pour un PATCH merge-patch+json, ce sont les seuls champs modifies. + * + * @return list + */ + private function payloadKeys(): array + { + $request = $this->requestStack->getCurrentRequest(); + if (null === $request) { + return []; + } + + $content = $request->getContent(); + + // Cache hit : meme corps brut que le dernier decodage -> memes cles. + if ($content === $this->decodedContent) { + return $this->decodedPayloadKeys; + } + + $this->decodedContent = $content; + $this->decodedPayloadKeys = $this->extractPayloadKeys($content); + + return $this->decodedPayloadKeys; + } + + /** + * Decode le corps brut et en extrait les cles de premier niveau (chaines). + * Corps vide ou JSON invalide -> aucune cle. + * + * @return list + */ + private function extractPayloadKeys(string $content): array + { + if ('' === $content) { + return []; + } + + try { + $decoded = json_decode($content, true, 512, JSON_THROW_ON_ERROR); + } catch (JsonException) { + return []; + } + + return is_array($decoded) ? array_values(array_filter(array_keys($decoded), 'is_string')) : []; + } + + /** + * Leve une 422 portant une violation unique sur `sites` — meme rendu Hydra que + * les contraintes Symfony, consommable inline par extractApiViolations (ERP-101). + * + * @return never + */ + private function throwSitesViolation(Provider $root): void + { + $violations = new ConstraintViolationList(); + $violations->add(new ConstraintViolation( + 'Vous ne pouvez rattacher que des sites auxquels vous avez accès.', + null, + [], + $root, + 'sites', + null, + )); + + throw new ValidationException($violations); + } +} diff --git a/src/Module/Technique/Infrastructure/ApiPlatform/State/Provider/ProviderProvider.php b/src/Module/Technique/Infrastructure/ApiPlatform/State/Provider/ProviderProvider.php new file mode 100644 index 0000000..5ed3645 --- /dev/null +++ b/src/Module/Technique/Infrastructure/ApiPlatform/State/Provider/ProviderProvider.php @@ -0,0 +1,256 @@ + (prestataires ayant >= 1 categorie + * de ce code, repetable) et ?siteId= (prestataires rattaches a ce site + * via la relation DIRECTE provider.sites, repetable) ; + * - pagination obligatoire (regle ABSOLUE n°13) : Paginator ORM ; echappatoire + * ?pagination=false pour alimenter un cote front). + if (!$this->pagination->isEnabled($operation, $context)) { + /** @var list $providers */ + $providers = $qb->getQuery()->getResult(); + // Hydratation batchee des collections affichees (§ 2.12) : evite le + // N+1 si la serialisation touche categories/sites, sans cartesien. + $this->repository->hydrateListCollections($providers); + + return $providers; + } + + $limit = $this->pagination->getLimit($operation, $context); + $page = max(1, $this->pagination->getPage($context)); + $offset = ($page - 1) * $limit; + + $qb->setFirstResult($offset)->setMaxResults($limit); + + // Le QB de selection ne porte pas de fetch-join to-many (§ 2.12) : le + // COUNT est simple, fetchJoinCollection inutile. On materialise la page + // puis on hydrate ses collections en lot (memes entites managees). + $paginator = new Paginator(new DoctrinePaginator($qb->getQuery(), fetchJoinCollection: false)); + $this->repository->hydrateListCollections(iterator_to_array($paginator)); + + return $paginator; + } + + /** + * @param array $uriVariables + */ + private function provideItem(array $uriVariables): ?Provider + { + $id = $uriVariables['id'] ?? null; + if (!is_int($id) && !(is_string($id) && ctype_digit($id))) { + return null; + } + + $provider = $this->repository->findById((int) $id); + if (null === $provider) { + return null; + } + + // Soft-delete : jamais expose au M3 (HP-M4) — 404 via retour null. + // Les archives restent visibles en detail (consultation + restauration). + if (null !== $provider->getDeletedAt()) { + return null; + } + + // Cloisonnement par site (RG-3.17) : un prestataire hors du perimetre de + // l'user -> 404 (ne pas reveler son existence). No-op pour bypass_scope ou + // currentSite null. + $scopeSite = $this->siteScopeOrNull(); + if (null !== $scopeSite && !$this->providerHasSite($provider, (int) $scopeSite->getId())) { + return null; + } + + return $provider; + } + + /** + * Site de cloisonnement a appliquer en LECTURE, ou null si aucun cloisonnement + * (user `sites.bypass_scope`, ou pas de site courant resolu — module Sites off + * / user sans currentSite, aligne site-aware.md § 5). + */ + private function siteScopeOrNull(): ?SiteInterface + { + if ($this->security->isGranted('sites.bypass_scope')) { + return null; + } + + return $this->currentSiteProvider->get(); + } + + /** + * Vrai si le prestataire est rattache (relation directe provider.sites) au + * site d'id donne. Comparaison en memoire sur l'entite deja chargee (detail). + */ + private function providerHasSite(Provider $provider, int $siteId): bool + { + foreach ($provider->getSites() as $site) { + if ($site instanceof SiteInterface && $site->getId() === $siteId) { + return true; + } + } + + return false; + } + + /** + * Lit un flag booleen issu des query params. Accepte true / "true" / "1". + */ + private function readBool(mixed $raw): bool + { + if (is_bool($raw)) { + return $raw; + } + + return is_string($raw) && in_array(strtolower($raw), ['true', '1'], true); + } + + /** + * Normalise un filtre en liste de chaines. Tolere un code unique (string) + * ou une liste (?key[]=a&key[]=b). Trim + retrait des vides. + * + * @return list + */ + private function readStringList(mixed $raw): array + { + $values = is_array($raw) ? $raw : [$raw]; + + $out = []; + foreach ($values as $value) { + if (is_string($value) && '' !== trim($value)) { + $out[] = trim($value); + } + } + + return $out; + } + + /** + * Normalise un filtre en liste d'identifiants entiers positifs. Tolere une + * valeur unique ou une liste (?key[]=1&key[]=2). + * + * @return list + */ + private function readIntList(mixed $raw): array + { + $values = is_array($raw) ? $raw : [$raw]; + + $out = []; + foreach ($values as $value) { + if ((is_int($value) || (is_string($value) && ctype_digit($value))) && (int) $value > 0) { + $out[] = (int) $value; + } + } + + return $out; + } +} diff --git a/src/Module/Technique/Infrastructure/Doctrine/DoctrineProviderRepository.php b/src/Module/Technique/Infrastructure/Doctrine/DoctrineProviderRepository.php new file mode 100644 index 0000000..ac5be4a --- /dev/null +++ b/src/Module/Technique/Infrastructure/Doctrine/DoctrineProviderRepository.php @@ -0,0 +1,287 @@ + + */ +class DoctrineProviderRepository extends ServiceEntityRepository implements ProviderRepositoryInterface +{ + public function __construct(ManagerRegistry $registry) + { + parent::__construct($registry, Provider::class); + } + + public function findById(int $id): ?Provider + { + return $this->find($id); + } + + public function save(Provider $provider): void + { + $this->getEntityManager()->persist($provider); + $this->getEntityManager()->flush(); + } + + public function createListQueryBuilder( + bool $includeArchived = false, + ?string $search = null, + array $categoryCodes = [], + array $siteIds = [], + bool $archivedOnly = false, + ): QueryBuilder { + // SELECTION uniquement (filtres + tri) : pas de fetch-join to-many ici. + // L'hydratation des collections affichees (Catégories / Site(s)) est + // deleguee a hydrateListCollections() une fois le jeu borne, pour ne pas + // imposer un produit cartesien aux chemins non pagines (export, + // ?pagination=false) — § 2.12 (cf. M1/ERP-100, M2). + $qb = $this->createQueryBuilder('p') + ->andWhere('p.deletedAt IS NULL') + ->orderBy('p.companyName', 'ASC') + ; + + // Perimetre d'archivage : archivedOnly prioritaire sur includeArchived. + if ($archivedOnly) { + $qb->andWhere('p.isArchived = true'); + } elseif (!$includeArchived) { + $qb->andWhere('p.isArchived = false'); + } + + $this->applySearch($qb, $search); + $this->applyCategoryCodes($qb, $categoryCodes); + $this->applySiteIds($qb, $siteIds); + + return $qb; + } + + public function hydrateListCollections(array $providers): void + { + $ids = $this->collectIds($providers); + if ([] === $ids) { + return; + } + + // 1re passe : categories (colonne « Catégories »). Produit p x cat seul. + $this->createQueryBuilder('p') + ->leftJoin('p.categories', 'cat')->addSelect('cat') + ->where('p.id IN (:ids)')->setParameter('ids', $ids) + ->getQuery() + ->getResult() + ; + + // 2e passe : sites (colonne « Site(s) »). SPECIFICITE M3 : les sites sont + // portes DIRECTEMENT par le prestataire (provider.sites, RG-3.03), pas via + // les adresses comme au M2 — d'ou un simple join p -> site (pas d'imbrication + // addr -> site). Separer des categories casse le cartesien cat x site. + $this->createQueryBuilder('p') + ->leftJoin('p.sites', 'site')->addSelect('site') + ->where('p.id IN (:ids)')->setParameter('ids', $ids) + ->getQuery() + ->getResult() + ; + } + + public function applySiteScope(QueryBuilder $qb, int $siteId): void + { + // Cloisonnement par site (RG-3.17, § 2.13) : ne garder que les prestataires + // dont provider.sites contient le site donne. Sous-requete IN (alias p5 + // distinct des filtres p2/p3/p4) pour ne pas perturber le tri/pagination du + // QueryBuilder principal — meme parti pris que applyCategoryCodes / applySiteIds. + // Parametre :scopeSiteId distinct de :siteIds (filtre ?siteId du client) pour + // que les deux clauses puissent coexister (intersection) sans collision. + $sub = $this->getEntityManager()->createQueryBuilder() + ->select('p5.id') + ->from(Provider::class, 'p5') + ->join('p5.sites', 'site5') + ->where('site5.id = :scopeSiteId') + ; + + $qb->andWhere($qb->expr()->in('p.id', $sub->getDQL())) + ->setParameter('scopeSiteId', $siteId) + ; + } + + public function hydrateContacts(array $providers): void + { + $ids = $this->collectIds($providers); + if ([] === $ids) { + return; + } + + // Une seule requete IN bornee : remplit la collection `contacts` des MEMES + // instances Provider (identity map). Tri par position pour que le « contact + // principal » (plus petit position) soit deterministe a l'export. + $this->createQueryBuilder('p') + ->leftJoin('p.contacts', 'pc')->addSelect('pc') + ->where('p.id IN (:ids)')->setParameter('ids', $ids) + ->orderBy('pc.position', 'ASC') + ->getQuery() + ->getResult() + ; + } + + /** + * Recherche fuzzy insensible a la casse sur companyName ET sur les contacts + * lies (firstName / lastName / email) — miroir M2. Les deux criteres sont unis + * par OR : un prestataire matche si son nom de societe OU l'un de ses contacts + * matche. Le critere contact passe par une sous-requete IN (plutot qu'un JOIN + * sur la collection) pour ne pas perturber le DISTINCT / ORDER BY / pagination + * principal. Les metacaracteres LIKE (%, _, \) saisis sont echappes pour rester + * litteraux. + */ + private function applySearch(QueryBuilder $qb, ?string $search): void + { + if (null === $search || '' === trim($search)) { + return; + } + + $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], trim($search)); + $pattern = '%'.mb_strtolower($escaped, 'UTF-8').'%'; + + $contactSub = $this->getEntityManager()->createQueryBuilder() + ->select('p2.id') + ->from(Provider::class, 'p2') + ->join('p2.contacts', 'pc2') + ->where('LOWER(pc2.firstName) LIKE :search') + ->orWhere('LOWER(pc2.lastName) LIKE :search') + ->orWhere('LOWER(pc2.email) LIKE :search') + ; + + $qb->andWhere( + $qb->expr()->orX( + 'LOWER(p.companyName) LIKE :search', + $qb->expr()->in('p.id', $contactSub->getDQL()), + ), + )->setParameter('search', $pattern); + } + + /** + * Restreint aux prestataires possedant au moins une categorie dont le code + * figure dans la liste (OR). Alimente le filtre « Catégories » du drawer. + * Sous-requete IN (plutot qu'un JOIN sur la collection M2M) pour ne pas + * perturber le DISTINCT / ORDER BY principal. + * + * @param list $categoryCodes + */ + private function applyCategoryCodes(QueryBuilder $qb, array $categoryCodes): void + { + $codes = $this->normalizeStringList($categoryCodes); + if ([] === $codes) { + return; + } + + $sub = $this->getEntityManager()->createQueryBuilder() + ->select('p3.id') + ->from(Provider::class, 'p3') + ->join('p3.categories', 'cat3') + ->where('cat3.code IN (:categoryCodes)') + ; + + $qb->andWhere($qb->expr()->in('p.id', $sub->getDQL())) + ->setParameter('categoryCodes', $codes) + ; + } + + /** + * Restreint aux prestataires rattaches a l'un des sites donnes (OR). SPECIFICITE + * M3 : les sites sont portes DIRECTEMENT par le prestataire (provider.sites, + * RG-3.03), d'ou une sous-requete sur p.sites (et non sur les adresses comme au + * M2). Sous-requete IN pour ne pas perturber le tri/pagination principal. + * + * @param list $siteIds + */ + private function applySiteIds(QueryBuilder $qb, array $siteIds): void + { + $ids = $this->normalizeIntList($siteIds); + if ([] === $ids) { + return; + } + + $sub = $this->getEntityManager()->createQueryBuilder() + ->select('p4.id') + ->from(Provider::class, 'p4') + ->join('p4.sites', 'site4') + ->where('site4.id IN (:siteIds)') + ; + + $qb->andWhere($qb->expr()->in('p.id', $sub->getDQL())) + ->setParameter('siteIds', $ids) + ; + } + + /** + * Extrait les identifiants non nuls d'un jeu de prestataires (entites managees). + * Les requetes d'hydratation renvoient les MEMES instances Provider (identity + * map), dont les collections sont alors remplies — anti N+1 a la serialisation. + * + * @param list $providers + * + * @return list + */ + private function collectIds(array $providers): array + { + $ids = []; + foreach ($providers as $provider) { + $id = $provider->getId(); + if (null !== $id) { + $ids[] = $id; + } + } + + return $ids; + } + + /** + * Nettoie une liste de chaines : trim, retrait des vides, reindexation. + * Defensive : tolere des elements scalaires non-string (cast) et ignore le + * reste sans lever de TypeError, le contrat etant de normaliser une entree + * potentiellement brute (query params). + * + * @param array $values + * + * @return list + */ + private function normalizeStringList(array $values): array + { + $out = []; + foreach ($values as $value) { + if (is_string($value) || is_int($value) || is_float($value)) { + $trimmed = trim((string) $value); + if ('' !== $trimmed) { + $out[] = $trimmed; + } + } + } + + return $out; + } + + /** + * Nettoie une liste d'identifiants : cast int, retrait des <= 0, reindexation. + * Defensive (cf. normalizeStringList) : accepte des entiers ou des chaines + * numeriques ('1', '2') sans TypeError, ignore le reste. + * + * @param array $values + * + * @return list + */ + private function normalizeIntList(array $values): array + { + $out = []; + foreach ($values as $value) { + if (is_numeric($value) && (int) $value > 0) { + $out[] = (int) $value; + } + } + + return $out; + } +} diff --git a/src/Module/Technique/TechniqueModule.php b/src/Module/Technique/TechniqueModule.php new file mode 100644 index 0000000..a5653cc --- /dev/null +++ b/src/Module/Technique/TechniqueModule.php @@ -0,0 +1,58 @@ + + */ + public static function permissions(): array + { + return [ + ['code' => 'technique.providers.view', 'label' => 'Voir les prestataires'], + ['code' => 'technique.providers.manage', 'label' => 'Créer / modifier les prestataires (hors onglet Comptabilité)'], + ['code' => 'technique.providers.accounting.view', 'label' => 'Voir l\'onglet Comptabilité d\'un prestataire'], + ['code' => 'technique.providers.accounting.manage', 'label' => 'Modifier l\'onglet Comptabilité d\'un prestataire'], + ['code' => 'technique.providers.archive', 'label' => 'Archiver / restaurer un prestataire'], + ]; + } +} diff --git a/src/Shared/Infrastructure/Database/ColumnCommentsCatalog.php b/src/Shared/Infrastructure/Database/ColumnCommentsCatalog.php index c2e0720..13f5770 100644 --- a/src/Shared/Infrastructure/Database/ColumnCommentsCatalog.php +++ b/src/Shared/Infrastructure/Database/ColumnCommentsCatalog.php @@ -361,6 +361,91 @@ final class ColumnCommentsCatalog 'iban' => 'IBAN du compte (≤ 34 caracteres).', 'position' => 'Ordre d affichage du RIB dans la liste du fournisseur (croissant).', ] + self::timestampableBlamableComments(), + + // Tables provider* (M3 Technique) — ajoutees au ticket entites (ERP-133), + // comme l a fait supplier (ERP-86) apres sa migration (ERP-85). En test, + // `schema:update --force` recree ces tables depuis le mapping ORM (sans + // COMMENT) ; `app:apply-column-comments` les repose depuis ce catalogue. + 'provider' => [ + '_table' => 'Repertoire prestataires (M3 Technique) — entites archivables (is_archived) et soft-deletables (deleted_at, HP M4). Pas d onglet Information (≠ supplier).', + 'id' => 'Identifiant interne auto-incremente.', + 'company_name' => 'Raison sociale du prestataire (stockee en MAJUSCULES). Unique case-insensitive parmi les actifs non archives/non supprimes (uq_provider_company_name_active, RG-3.10).', + 'siren' => 'Onglet Comptabilite : SIREN (9 chiffres attendus). NON unique — peut etre partage entre etablissements (RG-3.10).', + 'account_number' => 'Onglet Comptabilite : numero de compte comptable du prestataire.', + 'tva_mode_id' => 'Onglet Comptabilite : mode de TVA applique — FK -> tva_mode.id (referentiel partage M1), ON DELETE RESTRICT.', + 'n_tva' => 'Onglet Comptabilite : numero de TVA intracommunautaire.', + 'payment_delay_id' => 'Onglet Comptabilite : delai de reglement — FK -> payment_delay.id (M1), ON DELETE RESTRICT.', + 'payment_type_id' => 'Onglet Comptabilite : type de reglement — FK -> payment_type.id (M1), ON DELETE RESTRICT. Pilote RG-3.07 (Banque si VIREMENT) et RG-3.08 (RIB).', + 'bank_id' => 'Onglet Comptabilite : banque — FK -> bank.id (M1), ON DELETE RESTRICT. Obligatoire ssi payment_type = VIREMENT (RG-3.07), null sinon.', + 'is_archived' => 'Drapeau fonctionnel d archivage — masque par defaut dans la liste. Bascule via permission technique.providers.archive.', + 'archived_at' => 'Horodatage de l archivage — pose quand is_archived passe a vrai, remis a null a la restauration.', + 'deleted_at' => 'Horodatage du soft-delete technique (HP M4) — non expose par l API au M3. Null = ligne active.', + ] + self::timestampableBlamableComments(), + + 'provider_category' => [ + '_table' => 'Jointure M2M provider <-> category (Catalog) — categories de type PRESTATAIRE du prestataire, au moins une obligatoire (RG-3.09).', + 'provider_id' => 'FK -> provider.id, ON DELETE CASCADE — prestataire porteur de la categorie.', + 'category_id' => 'FK -> category.id, ON DELETE RESTRICT — categorie de type PRESTATAIRE rattachee au prestataire (RG-3.09).', + ], + + 'provider_site' => [ + '_table' => 'Jointure M2M provider <-> site (Sites) — sites du prestataire, selecteur du formulaire principal, au moins un obligatoire (RG-3.03). Sert le cloisonnement par site (§ 2.13).', + 'provider_id' => 'FK -> provider.id, ON DELETE CASCADE — prestataire porteur du site.', + 'site_id' => 'FK -> site.id, ON DELETE RESTRICT — site rattache au prestataire (RG-3.03, idx_provider_site_site).', + ], + + 'provider_contact' => [ + '_table' => 'Contacts d un prestataire (1:n) — au moins un champ rempli parmi prenom/nom/telephone/email (RG-3.04, chk_provider_contact_name).', + 'id' => 'Identifiant interne auto-incremente.', + 'provider_id' => 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire du contact.', + 'first_name' => 'Prenom du contact (capitalise serveur). Au moins un champ du contact requis (RG-3.04, chk_provider_contact_name).', + 'last_name' => 'Nom du contact (capitalise serveur). Au moins un champ du contact requis (RG-3.04, chk_provider_contact_name).', + 'job_title' => 'Fonction / intitule de poste du contact (≤ 120 caracteres).', + 'phone_primary' => 'Telephone principal du contact — chiffres uniquement (normalisation serveur).', + 'phone_secondary' => 'Telephone secondaire du contact — chiffres uniquement (normalisation serveur).', + 'email' => 'Email du contact (lowercase serveur).', + 'position' => 'Ordre d affichage du contact dans la liste du prestataire (croissant).', + ] + self::timestampableBlamableComments(), + + 'provider_address' => [ + '_table' => 'Adresses d un prestataire (1:n) — >= 1 site rattache (RG-3.05). SANS address_type / bennes / triage_provider (specifiques fournisseur).', + 'id' => 'Identifiant interne auto-incremente.', + 'provider_id' => 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire de l adresse.', + 'country' => 'Pays de l adresse — defaut France.', + 'postal_code' => 'Code postal (4-5 chiffres attendus) — declenche l autocompletion ville via l API BAN cote front (RG-3.06).', + 'city' => 'Ville — preremplie depuis le code postal via API BAN cote front.', + 'street' => 'Numero et voie de l adresse.', + 'street_complement' => 'Complement d adresse (etage, batiment...) — optionnel.', + 'position' => 'Ordre d affichage de l adresse dans la liste du prestataire (croissant).', + ] + self::timestampableBlamableComments(), + + 'provider_address_site' => [ + '_table' => 'Jointure M2M provider_address <-> site (Sites) — sites rattaches a l adresse (>= 1 obligatoire, RG-3.05).', + 'provider_address_id' => 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.', + 'site_id' => 'FK -> site.id, ON DELETE RESTRICT — site rattache a l adresse.', + ], + + 'provider_address_contact' => [ + '_table' => 'Jointure M2M provider_address <-> provider_contact — contacts associes a une adresse.', + 'provider_address_id' => 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.', + 'provider_contact_id' => 'FK -> provider_contact.id, ON DELETE CASCADE — contact associe a l adresse.', + ], + + 'provider_address_category' => [ + '_table' => 'Jointure M2M provider_address <-> category — categories d adresse de type PRESTATAIRE (RG-3.09).', + 'provider_address_id' => 'FK -> provider_address.id, ON DELETE CASCADE — adresse concernee.', + 'category_id' => 'FK -> category.id, ON DELETE RESTRICT — categorie d adresse de type PRESTATAIRE (RG-3.09).', + ], + + 'provider_rib' => [ + '_table' => 'Coordonnees bancaires d un prestataire (1:n) — >= 1 RIB attendu selon le type de reglement (RG-3.08). Tous les champs audites (pas d AuditIgnore).', + 'id' => 'Identifiant interne auto-incremente.', + 'provider_id' => 'FK -> provider.id, ON DELETE CASCADE — prestataire proprietaire du RIB.', + 'label' => 'Libelle du RIB (ex: compte principal).', + 'bic' => 'Code BIC/SWIFT de la banque (8 ou 11 caracteres).', + 'iban' => 'IBAN du compte (≤ 34 caracteres).', + 'position' => 'Ordre d affichage du RIB dans la liste du prestataire (croissant).', + ] + self::timestampableBlamableComments(), ]; } diff --git a/tests/Architecture/EntityConstraintsHaveFrenchMessageTest.php b/tests/Architecture/EntityConstraintsHaveFrenchMessageTest.php index fb5d338..1e2213f 100644 --- a/tests/Architecture/EntityConstraintsHaveFrenchMessageTest.php +++ b/tests/Architecture/EntityConstraintsHaveFrenchMessageTest.php @@ -54,6 +54,8 @@ final class EntityConstraintsHaveFrenchMessageTest extends TestCase 'ClientAddress::postalCode' => 'Regex {4,5} borne deja la longueur.', // Idem cote fournisseur (meme Regex CP). 'SupplierAddress::postalCode' => 'Regex {4,5} borne deja la longueur.', + // Idem cote prestataire (meme Regex CP — M3 Technique). + 'ProviderAddress::postalCode' => 'Regex {4,5} borne deja la longueur.', // Le Choice {PROSPECT,DEPART,RENDU} borne les valeurs (<= 8 < 20). 'SupplierAddress::addressType' => 'Choice {PROSPECT,DEPART,RENDU} borne deja les valeurs.', // Le Regex /^#[0-9A-Fa-f]{6}$/ borne la longueur a exactement 7 caracteres. diff --git a/tests/Module/Catalog/Api/CategoryPrestataireSeedTest.php b/tests/Module/Catalog/Api/CategoryPrestataireSeedTest.php new file mode 100644 index 0000000..b1a9b05 --- /dev/null +++ b/tests/Module/Catalog/Api/CategoryPrestataireSeedTest.php @@ -0,0 +1,107 @@ +getOrCreatePrestataireType(); + foreach (self::PROVIDER_CATEGORIES as $name) { + $this->createCategory($name, $providerType); + } + + // Bruit : un type + une categorie d'un autre type ne doivent PAS fuiter. + $noiseType = $this->createCategoryType('TEST_FOURNISSEUR', 'Test Fournisseur'); + $this->createCategory(self::TEST_CATEGORY_PREFIX.'noise', $noiseType); + + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/categories?typeCode=PRESTATAIRE&pagination=false'); + self::assertSame(200, $response->getStatusCode()); + + $members = $response->toArray()['member']; + $names = array_map(static fn (array $m): string => $m['name'], $members); + sort($names); + + $expected = self::PROVIDER_CATEGORIES; + sort($expected); + self::assertSame( + $expected, + $names, + 'Le filtre ?typeCode=PRESTATAIRE doit ne renvoyer QUE les categories du type PRESTATAIRE.', + ); + + // Chaque categorie remontee doit PORTER le type PRESTATAIRE. + foreach ($members as $member) { + self::assertContains('PRESTATAIRE', array_column($member['categoryTypes'], 'code')); + } + } + + public function testTypeCodePrestataireKeepsHydraPagination(): void + { + $providerType = $this->getOrCreatePrestataireType(); + $this->createCategory('Maintenance industrielle', $providerType); + + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/categories?typeCode=PRESTATAIRE'); + self::assertSame(200, $response->getStatusCode()); + + $data = $response->toArray(); + self::assertArrayHasKey('totalItems', $data, 'Le filtre ne doit pas casser la pagination Hydra.'); + self::assertArrayHasKey('member', $data); + + foreach ($data['member'] as $member) { + self::assertContains('PRESTATAIRE', array_column($member['categoryTypes'], 'code')); + } + } + + /** + * Recupere le type PRESTATAIRE reel, ou le cree s'il est absent. Le code + * `PRESTATAIRE` est seede par CategoryTypeFixtures (present en debut de suite), + * mais le cleanup purge tous les `category_type` entre les tests : selon + * l'ordre d'execution, le type peut donc exister ou non. Le get-or-create rend + * le test robuste sans dependre du seed ni le dupliquer. + */ + private function getOrCreatePrestataireType(): CategoryType + { + $em = $this->getEm(); + $existing = $em->getRepository(CategoryType::class)->findOneBy(['code' => 'PRESTATAIRE']); + + if ($existing instanceof CategoryType) { + return $existing; + } + + return $this->createCategoryType('PRESTATAIRE', 'Prestataire'); + } +} diff --git a/tests/Module/Technique/Api/AbstractProviderApiTestCase.php b/tests/Module/Technique/Api/AbstractProviderApiTestCase.php new file mode 100644 index 0000000..5e5d5e3 --- /dev/null +++ b/tests/Module/Technique/Api/AbstractProviderApiTestCase.php @@ -0,0 +1,287 @@ +getEm(); + + $em->createQuery('DELETE FROM '.Provider::class)->execute(); + $em->createQuery('DELETE FROM '.Category::class.' c WHERE c.name LIKE :prefix') + ->setParameter('prefix', self::TEST_CATEGORY_PREFIX.'%')->execute() + ; + $em->createQuery('DELETE FROM '.User::class.' u WHERE u.username LIKE :prefix') + ->setParameter('prefix', 'test_%')->execute() + ; + $em->createQuery('DELETE FROM '.Role::class.' r WHERE r.code LIKE :prefix') + ->setParameter('prefix', 'test_%')->execute() + ; + + parent::tearDown(); + } + + protected function createAdminClient(): Client + { + return $this->authenticatedClient('admin', 'admin'); + } + + /** + * Recupere (ou cree) le type PRESTATAIRE. Idempotent (unicite category_type.code). + */ + protected function providerCategoryType(): CategoryType + { + $em = $this->getEm(); + $existing = $em->getRepository(CategoryType::class)->findOneBy(['code' => 'PRESTATAIRE']); + if (null !== $existing) { + return $existing; + } + + $type = new CategoryType(); + $type->setCode('PRESTATAIRE'); + $type->setLabel('Prestataire'); + $em->persist($type); + $em->flush(); + + return $type; + } + + /** + * Fetch-or-create une categorie de type PRESTATAIRE par code (defaut NETTOYAGE). + * Idempotent (lookup par code, aligne sur l'index unique partiel uq_category_code) + * et auto-suffisant. Nom prefixe -> purge par tearDown. + */ + protected function providerCategory(string $code = 'NETTOYAGE'): Category + { + $em = $this->getEm(); + $existing = $em->getRepository(Category::class)->findOneBy(['code' => $code, 'deletedAt' => null]); + if (null !== $existing) { + return $existing; + } + + $category = new Category(); + $category->setName(self::TEST_CATEGORY_PREFIX.strtolower($code)); + $category->setCode($code); + $category->addCategoryType($this->providerCategoryType()); + $em->persist($category); + $em->flush(); + + return $category; + } + + /** + * Cree une categorie d'un type DIFFERENT de PRESTATAIRE (pour tester le rejet + * RG-3.09). Code unique pour ne pas collisionner avec une categorie existante. + */ + protected function foreignCategory(): Category + { + $em = $this->getEm(); + $suffix = substr(bin2hex(random_bytes(4)), 0, 8); + + $type = $em->getRepository(CategoryType::class)->findOneBy(['code' => 'CLIENT']); + if (null === $type) { + $type = new CategoryType(); + $type->setCode('CLIENT'); + $type->setLabel('Client'); + $em->persist($type); + } + + $category = new Category(); + $category->setName(self::TEST_CATEGORY_PREFIX.'foreign_'.$suffix); + $category->setCode('FOREIGN_'.strtoupper($suffix)); + $category->addCategoryType($type); + $em->persist($category); + $em->flush(); + + return $category; + } + + /** + * Recupere un site fixture par code postal (cf. SitesFixtures). Echoue + * explicitement si absent (fixtures non chargees / module Sites off). + */ + protected function site(string $postalCode): Site + { + $site = $this->getEm()->getRepository(Site::class)->findOneBy(['postalCode' => $postalCode]); + + self::assertNotNull( + $site, + sprintf('Site fixture "%s" introuvable : SitesFixtures charge (make test-db-setup) ?', $postalCode), + ); + + return $site; + } + + /** + * Seede directement un Provider minimal (sans passer par l'API), pour les tests + * de liste / archivage / cloisonnement. Nom stocke en MAJUSCULES pour refleter + * l'etat normalise (RG-3.11) qu'aurait produit le ProviderProcessor. Porte une + * categorie PRESTATAIRE + les sites donnes (par code postal). + * + * @param list $sitePostalCodes codes postaux des sites a rattacher + */ + protected function seedProvider( + string $companyName, + array $sitePostalCodes = [self::SITE_86], + bool $isArchived = false, + string $categoryCode = 'NETTOYAGE', + ?string $siren = null, + ): Provider { + $em = $this->getEm(); + $provider = new Provider(); + $provider->setCompanyName(mb_strtoupper($companyName, 'UTF-8')); + $provider->addCategory($this->providerCategory($categoryCode)); + foreach ($sitePostalCodes as $postalCode) { + $provider->addSite($this->site($postalCode)); + } + if (null !== $siren) { + $provider->setSiren($siren); + } + $provider->setIsArchived($isArchived); + if ($isArchived) { + $provider->setArchivedAt(new DateTimeImmutable()); + } + $em->persist($provider); + $em->flush(); + + return $provider; + } + + /** + * Payload minimal valide du formulaire principal (companyName + 1 categorie + * PRESTATAIRE + sites donnes). Categorie NETTOYAGE par defaut. + * + * @param list $sitePostalCodes + * + * @return array + */ + protected function validMainPayload(string $companyName, array $sitePostalCodes = [self::SITE_86]): array + { + $siteIris = array_map(fn (string $pc): string => '/api/sites/'.$this->site($pc)->getId(), $sitePostalCodes); + + return [ + 'companyName' => $companyName, + 'categories' => ['/api/categories/'.$this->providerCategory()->getId()], + 'sites' => $siteIris, + ]; + } + + /** + * Cree un utilisateur non-admin CLOISONNE : porte les permissions donnees via + * un role jetable, rattache aux seuls sites donnes (par code postal), avec un + * currentSite positionne. N'a PAS `sites.bypass_scope` (sauf si fourni dans + * $permissionCodes) -> sujet ideal des tests de cloisonnement (RG-3.17). + * + * Contrairement a createUserWithPermissions() (parent, qui attache TOUS les + * sites et ne pose pas de currentSite), ce helper controle finement le + * perimetre site de l'user. + * + * @param list $permissionCodes + * @param list $sitePostalCodes sites a rattacher (user_site) + * + * @return array{username: string, password: string} + */ + protected function createScopedUser( + array $permissionCodes, + array $sitePostalCodes, + ?string $currentSitePostalCode = null, + ): array { + $em = $this->getEm(); + + $suffix = substr(bin2hex(random_bytes(4)), 0, 8); + $username = 'test_scoped_'.$suffix; + $password = 'testpass'; + + /** @var UserPasswordHasherInterface $hasher */ + $hasher = self::getContainer()->get(UserPasswordHasherInterface::class); + + $role = new Role('test_'.$suffix, 'Test Role '.$suffix, false); + foreach ($permissionCodes as $code) { + $permission = $em->getRepository(Permission::class)->findOneBy(['code' => $code]); + self::assertNotNull($permission, sprintf('Permission "%s" introuvable (app:sync-permissions ?).', $code)); + $role->addPermission($permission); + } + $em->persist($role); + + $user = new User(); + $user->setUsername($username); + $user->setIsAdmin(false); + $user->setPassword($hasher->hashPassword($user, $password)); + $user->addRbacRole($role); + + foreach ($sitePostalCodes as $postalCode) { + $user->addSite($this->site($postalCode)); + } + if (null !== $currentSitePostalCode) { + $user->setCurrentSite($this->site($currentSitePostalCode)); + } + + $em->persist($user); + $em->flush(); + $em->clear(); + + return ['username' => $username, 'password' => $password]; + } + + /** + * Indexe les violations d'un corps 422 par propertyPath (assert ciblee). + * + * @param array $body corps decode (toArray(false)) + * + * @return array propertyPath => message + */ + protected function violationsByPath(array $body): array + { + $byPath = []; + foreach ($body['violations'] ?? [] as $v) { + $byPath[$v['propertyPath']] = $v['message']; + } + + return $byPath; + } +} diff --git a/tests/Module/Technique/Api/ProviderApiTest.php b/tests/Module/Technique/Api/ProviderApiTest.php new file mode 100644 index 0000000..82c8a14 --- /dev/null +++ b/tests/Module/Technique/Api/ProviderApiTest.php @@ -0,0 +1,115 @@ +createAdminClient(); + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $this->validMainPayload('Maintenance Pro', [self::SITE_86]), + ]); + + self::assertSame(201, $response->getStatusCode()); + $body = $response->toArray(); + // RG-3.11 : companyName normalise en MAJUSCULES. + self::assertSame('MAINTENANCE PRO', $body['companyName']); + self::assertArrayHasKey('id', $body); + // sites embarque (relation directe, site:read) avec name/postalCode. + self::assertCount(1, $body['sites']); + self::assertSame('86100', $body['sites'][0]['postalCode']); + } + + public function testPostWithoutSiteIsRejected(): void + { + $client = $this->createAdminClient(); + + $payload = $this->validMainPayload('Sans Site', [self::SITE_86]); + $payload['sites'] = []; + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $payload, + ]); + + // RG-3.03 : au moins un site obligatoire. + self::assertSame(422, $response->getStatusCode()); + self::assertArrayHasKey('sites', $this->violationsByPath($response->toArray(false))); + } + + public function testPostWithoutCategoryIsRejected(): void + { + $client = $this->createAdminClient(); + + $payload = $this->validMainPayload('Sans Categorie', [self::SITE_86]); + $payload['categories'] = []; + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $payload, + ]); + + // RG-3.09 : au moins une categorie obligatoire. + self::assertSame(422, $response->getStatusCode()); + self::assertArrayHasKey('categories', $this->violationsByPath($response->toArray(false))); + } + + public function testPostWithForeignCategoryTypeIsRejected(): void + { + $client = $this->createAdminClient(); + $foreign = $this->foreignCategory(); + + $payload = $this->validMainPayload('Mauvais Type', [self::SITE_86]); + $payload['categories'] = ['/api/categories/'.$foreign->getId()]; + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $payload, + ]); + + // RG-3.09 : categorie hors type PRESTATAIRE -> 422 sur `categories`. + self::assertSame(422, $response->getStatusCode()); + self::assertArrayHasKey('categories', $this->violationsByPath($response->toArray(false))); + } + + public function testDuplicateCompanyNameReturns409(): void + { + $this->seedProvider('Doublon Sarl', [self::SITE_86]); + $client = $this->createAdminClient(); + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + // Casse differente : l'unicite est insensible a la casse (LOWER). + 'json' => $this->validMainPayload('doublon sarl', [self::SITE_86]), + ]); + + // RG-3.10 : doublon de nom (case-insensitive) -> 409. + self::assertSame(409, $response->getStatusCode()); + } + + public function testSameNameAfterArchiveIsAllowed(): void + { + // Index partiel : l'unicite ignore les archives -> reutilisation du nom OK. + $this->seedProvider('Recyclage Express', [self::SITE_86], isArchived: true); + $client = $this->createAdminClient(); + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $this->validMainPayload('Recyclage Express', [self::SITE_86]), + ]); + + self::assertSame(201, $response->getStatusCode()); + } +} diff --git a/tests/Module/Technique/Api/ProviderListTest.php b/tests/Module/Technique/Api/ProviderListTest.php new file mode 100644 index 0000000..367d253 --- /dev/null +++ b/tests/Module/Technique/Api/ProviderListTest.php @@ -0,0 +1,83 @@ + pas de cloisonnement). + * + * @internal + */ +final class ProviderListTest extends AbstractProviderApiTestCase +{ + public function testListReturnsHydraEnvelopeSortedByName(): void + { + $this->seedProvider('Zeta Services', [self::SITE_86]); + $this->seedProvider('Alpha Nettoyage', [self::SITE_86]); + $this->seedProvider('Mu Maintenance', [self::SITE_86]); + + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/providers', [ + 'headers' => ['Accept' => self::LD], + ]); + + self::assertSame(200, $response->getStatusCode()); + $body = $response->toArray(); + + // Envelope Hydra : totalItems present + member. + self::assertSame(3, $body['totalItems']); + $names = array_column($body['member'], 'companyName'); + // Tri companyName ASC (RG-3.16) — noms normalises en MAJUSCULES. + self::assertSame(['ALPHA NETTOYAGE', 'MU MAINTENANCE', 'ZETA SERVICES'], $names); + } + + public function testListExcludesArchivedByDefault(): void + { + $this->seedProvider('Actif Sas', [self::SITE_86]); + $this->seedProvider('Archive Sarl', [self::SITE_86], isArchived: true); + + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/providers', [ + 'headers' => ['Accept' => self::LD], + ]); + + self::assertSame(200, $response->getStatusCode()); + $body = $response->toArray(); + self::assertSame(1, $body['totalItems']); + self::assertSame('ACTIF SAS', $body['member'][0]['companyName']); + } + + public function testListIncludeArchivedReintegratesArchived(): void + { + $this->seedProvider('Actif Sas', [self::SITE_86]); + $this->seedProvider('Archive Sarl', [self::SITE_86], isArchived: true); + + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/providers?includeArchived=true', [ + 'headers' => ['Accept' => self::LD], + ]); + + self::assertSame(200, $response->getStatusCode()); + self::assertSame(2, $response->toArray()['totalItems']); + } + + public function testListFiltersBySiteIdViaDirectRelation(): void + { + $this->seedProvider('Site 86 Only', [self::SITE_86]); + $this->seedProvider('Site 17 Only', [self::SITE_17]); + + $client = $this->createAdminClient(); + $site17 = $this->site(self::SITE_17); + $response = $client->request('GET', '/api/providers?siteId='.$site17->getId(), [ + 'headers' => ['Accept' => self::LD], + ]); + + self::assertSame(200, $response->getStatusCode()); + $body = $response->toArray(); + self::assertSame(1, $body['totalItems']); + self::assertSame('SITE 17 ONLY', $body['member'][0]['companyName']); + } +} diff --git a/tests/Module/Technique/Api/ProviderRbacGatingTest.php b/tests/Module/Technique/Api/ProviderRbacGatingTest.php new file mode 100644 index 0000000..72ca13b --- /dev/null +++ b/tests/Module/Technique/Api/ProviderRbacGatingTest.php @@ -0,0 +1,159 @@ + CurrentSiteProvider::get() = null -> aucun + * cloisonnement, on isole ainsi le comportement RBAC du comportement site. + * + * @internal + */ +final class ProviderRbacGatingTest extends AbstractProviderApiTestCase +{ + public function testAccountingFieldsOmittedWithoutAccountingView(): void + { + $provider = $this->seedProvider('Compta Masquee', [self::SITE_86], siren: '123456789'); + $id = $provider->getId(); + + // Profil type Commerciale : view + manage SANS accounting.view. + $creds = $this->createUserWithPermissions(['technique.providers.view']); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('GET', '/api/providers/'.$id, ['headers' => ['Accept' => self::LD]]); + self::assertSame(200, $response->getStatusCode()); + + $body = $response->toArray(); + // Gating par omission : scalaires comptables ET ribs totalement absents. + self::assertArrayNotHasKey('siren', $body); + self::assertArrayNotHasKey('ribs', $body); + // isArchived reste expose (bug #3 M1 : la cle ne doit pas etre droppee). + self::assertArrayHasKey('isArchived', $body); + } + + public function testAccountingFieldsPresentWithAccountingView(): void + { + $provider = $this->seedProvider('Compta Visible', [self::SITE_86], siren: '987654321'); + $id = $provider->getId(); + + $creds = $this->createUserWithPermissions([ + 'technique.providers.view', + 'technique.providers.accounting.view', + ]); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('GET', '/api/providers/'.$id, ['headers' => ['Accept' => self::LD]]); + self::assertSame(200, $response->getStatusCode()); + + $body = $response->toArray(); + self::assertSame('987654321', $body['siren']); + // La cle ribs apparait (collection vide ici, mais presente). + self::assertArrayHasKey('ribs', $body); + } + + public function testStrictModeRejectsMixedGroupsForManageOnlyUser(): void + { + $provider = $this->seedProvider('Strict Cible', [self::SITE_86]); + $id = $provider->getId(); + + // Profil type Bureau : manage SANS accounting.manage. + $creds = $this->createUserWithPermissions([ + 'technique.providers.view', + 'technique.providers.manage', + ]); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['companyName' => 'Renomme', 'siren' => '111222333'], + ]); + + // RG-3.15 : payload melangeant main + accounting sans accounting.manage + // -> 403 sur tout le payload (mode strict, pas de filtrage silencieux). + self::assertSame(403, $response->getStatusCode()); + + // Aucun champ n'a ete persiste (rollback du mode strict). + $this->getEm()->clear(); + $reloaded = $this->getEm()->getRepository(Provider::class)->find($id); + self::assertSame('STRICT CIBLE', $reloaded->getCompanyName()); + self::assertNull($reloaded->getSiren()); + } + + public function testAccountingOnlyUserCanPatchAccountingButNotMain(): void + { + $provider = $this->seedProvider('Compta Editrice', [self::SITE_86]); + $id = $provider->getId(); + + // Profil type Compta : accounting.view + accounting.manage SANS manage. + $creds = $this->createUserWithPermissions([ + 'technique.providers.view', + 'technique.providers.accounting.view', + 'technique.providers.accounting.manage', + ]); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + // PATCH accounting -> 200. + $ok = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['siren' => '555666777'], + ]); + self::assertSame(200, $ok->getStatusCode()); + + // PATCH main (companyName) -> 403 (pas de permission manage). + $ko = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['companyName' => 'Interdit'], + ]); + self::assertSame(403, $ko->getStatusCode()); + } + + public function testArchiveRequiresArchivePermission(): void + { + $provider = $this->seedProvider('A Archiver', [self::SITE_86]); + $id = $provider->getId(); + + // Bureau (manage) sans archive -> 403. + $creds = $this->createUserWithPermissions([ + 'technique.providers.view', + 'technique.providers.manage', + ]); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['isArchived' => true], + ]); + + // RG-3.13 : l'archivage exige technique.providers.archive. + self::assertSame(403, $response->getStatusCode()); + } + + public function testAdminCanArchiveAndSetsArchivedAt(): void + { + $provider = $this->seedProvider('Archivable', [self::SITE_86]); + $id = $provider->getId(); + + $client = $this->createAdminClient(); + $response = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['isArchived' => true], + ]); + + self::assertSame(200, $response->getStatusCode()); + + $this->getEm()->clear(); + $reloaded = $this->getEm()->getRepository(Provider::class)->find($id); + self::assertTrue($reloaded->isArchived()); + self::assertNotNull($reloaded->getArchivedAt()); + } +} diff --git a/tests/Module/Technique/Api/ProviderSiteScopeTest.php b/tests/Module/Technique/Api/ProviderSiteScopeTest.php new file mode 100644 index 0000000..21259e9 --- /dev/null +++ b/tests/Module/Technique/Api/ProviderSiteScopeTest.php @@ -0,0 +1,171 @@ + 422). + * + * Cloisonnement pilote par l'USER (pas le role) : on cree des users non-admin SANS + * `sites.bypass_scope`, rattaches a un site precis avec un currentSite. L'admin + * (isAdmin -> bypass total) sert de temoin « voit tout ». + * + * @internal + */ +final class ProviderSiteScopeTest extends AbstractProviderApiTestCase +{ + protected function setUp(): void + { + parent::setUp(); + // Pre-requis : le module Sites doit etre actif (sinon currentSite = null, + // cloisonnement no-op et ces tests perdent leur sens). + $this->skipIfSitesModuleDisabled(); + } + + public function testListIsScopedToCurrentSiteForNonBypassUser(): void + { + $this->seedProvider('Presta Site 86', [self::SITE_86]); + $this->seedProvider('Presta Site 17', [self::SITE_17]); + $this->seedProvider('Presta Site 82', [self::SITE_82]); + + $creds = $this->createScopedUser( + ['technique.providers.view'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('GET', '/api/providers', ['headers' => ['Accept' => self::LD]]); + self::assertSame(200, $response->getStatusCode()); + + $body = $response->toArray(); + // totalItems reflete le PERIMETRE de l'user (filtre avant pagination). + self::assertSame(1, $body['totalItems']); + self::assertSame('PRESTA SITE 86', $body['member'][0]['companyName']); + } + + public function testDetailOutOfScopeReturns404(): void + { + $inScope = $this->seedProvider('Dans Perimetre', [self::SITE_86]); + $outOfScope = $this->seedProvider('Hors Perimetre', [self::SITE_17]); + + $creds = $this->createScopedUser( + ['technique.providers.view'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + // In-scope -> 200. + $ok = $client->request('GET', '/api/providers/'.$inScope->getId(), ['headers' => ['Accept' => self::LD]]); + self::assertSame(200, $ok->getStatusCode()); + + // Out-of-scope -> 404 (ne pas reveler l'existence hors perimetre). + $ko = $client->request('GET', '/api/providers/'.$outOfScope->getId(), ['headers' => ['Accept' => self::LD]]); + self::assertSame(404, $ko->getStatusCode()); + } + + public function testBypassUserSeesAllSites(): void + { + $this->seedProvider('Presta Site 86', [self::SITE_86]); + $this->seedProvider('Presta Site 17', [self::SITE_17]); + $this->seedProvider('Presta Site 82', [self::SITE_82]); + + // Admin = bypass total. + $client = $this->createAdminClient(); + $response = $client->request('GET', '/api/providers', ['headers' => ['Accept' => self::LD]]); + + self::assertSame(200, $response->getStatusCode()); + self::assertSame(3, $response->toArray()['totalItems']); + } + + public function testWriteOutOfScopeSiteRejectedAtIriResolution(): void + { + // User non-bypass / non-read_ref : la resolution de l'IRI du site hors + // perimetre echoue en amont (SiteCollectionScopedExtension : item Site + // « introuvable ») -> 400 anti-enumeration, avant le ProviderProcessor. + $creds = $this->createScopedUser( + ['technique.providers.view', 'technique.providers.manage'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $this->validMainPayload('Hors Scope Sas', [self::SITE_17]), + ]); + + self::assertSame(400, $response->getStatusCode()); + } + + public function testWriteOutOfScopeSiteRejectedByProcessorGuard(): void + { + // User `sites.read_ref` : peut RESOUDRE n'importe quel site (referentiel + // transverse) mais n'opere que sur ses user_site. La garde guardSiteScope + // du ProviderProcessor est alors l'enforcement autoritaire de RG-3.17 + // -> 422 sur `sites` (mappable inline, ERP-101). + $creds = $this->createScopedUser( + ['technique.providers.view', 'technique.providers.manage', 'sites.read_ref'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $this->validMainPayload('Hors Scope Guard', [self::SITE_17]), + ]); + + self::assertSame(422, $response->getStatusCode()); + self::assertArrayHasKey('sites', $this->violationsByPath($response->toArray(false))); + } + + public function testWriteAllowsSiteWithinUserScope(): void + { + $creds = $this->createScopedUser( + ['technique.providers.view', 'technique.providers.manage'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + // Site 86 = un des user_site -> 201. + $response = $client->request('POST', '/api/providers', [ + 'headers' => ['Content-Type' => self::LD], + 'json' => $this->validMainPayload('Dans Scope Sas', [self::SITE_86]), + ]); + + self::assertSame(201, $response->getStatusCode()); + } + + public function testPatchAddingOutOfScopeSiteIsRejected(): void + { + $provider = $this->seedProvider('Patch Sites', [self::SITE_86]); + $id = $provider->getId(); + + // read_ref pour pouvoir resoudre l'IRI du site 17 (sinon 400 en amont) et + // exercer la garde guardSiteScope sur le PATCH. + $creds = $this->createScopedUser( + ['technique.providers.view', 'technique.providers.manage', 'sites.read_ref'], + sitePostalCodes: [self::SITE_86], + currentSitePostalCode: self::SITE_86, + ); + $client = $this->authenticatedClient($creds['username'], $creds['password']); + + $site86 = $this->site(self::SITE_86)->getId(); + $site17 = $this->site(self::SITE_17)->getId(); + + $response = $client->request('PATCH', '/api/providers/'.$id, [ + 'headers' => ['Content-Type' => self::MERGE], + 'json' => ['sites' => ['/api/sites/'.$site86, '/api/sites/'.$site17]], + ]); + + // RG-3.17 : ajouter un site hors user_site -> 422 (garde Processor). + self::assertSame(422, $response->getStatusCode()); + self::assertArrayHasKey('sites', $this->violationsByPath($response->toArray(false))); + } +} diff --git a/tests/Module/Technique/TechniqueModuleTest.php b/tests/Module/Technique/TechniqueModuleTest.php new file mode 100644 index 0000000..bf3286d --- /dev/null +++ b/tests/Module/Technique/TechniqueModuleTest.php @@ -0,0 +1,59 @@ +