Matthieu
9a6ec71981
- Provider::validatePaymentTypeConsistency (Assert\Callback, miroir Supplier ERP-89) : RG-3.07 VIREMENT impose une banque (violation sur bank), RG-3.08 LCR impose au moins un RIB (violation sur paymentType). - ProviderProcessor : docblock realigne (RG-3.07/3.08 portees par l'entite). - AbstractProviderApiTestCase::bank() helper referentiel. - ProviderAccountingValidationTest : 4 cas (negatif 422 / positif 200) par RG. Les RG-3.03/3.05/3.09 (contraintes d'entite) et l'ecriture cloisonnee (gardes processors, RG-3.17/2.13) etaient deja posees en ERP-133/134/135 et restent couvertes.
608 lines
24 KiB
PHP
608 lines
24 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Module\Technique\Domain\Entity;
|
|
|
|
use ApiPlatform\Metadata\ApiResource;
|
|
use ApiPlatform\Metadata\Get;
|
|
use ApiPlatform\Metadata\GetCollection;
|
|
use ApiPlatform\Metadata\Patch;
|
|
use ApiPlatform\Metadata\Post;
|
|
use App\Module\Commercial\Domain\Entity\Bank;
|
|
use App\Module\Commercial\Domain\Entity\PaymentDelay;
|
|
use App\Module\Commercial\Domain\Entity\PaymentType;
|
|
use App\Module\Commercial\Domain\Entity\TvaMode;
|
|
use App\Module\Technique\Infrastructure\ApiPlatform\State\Processor\ProviderProcessor;
|
|
use App\Module\Technique\Infrastructure\ApiPlatform\State\Provider\ProviderProvider;
|
|
use App\Module\Technique\Infrastructure\Doctrine\DoctrineProviderRepository;
|
|
use App\Shared\Domain\Attribute\Auditable;
|
|
use App\Shared\Domain\Contract\BlamableInterface;
|
|
use App\Shared\Domain\Contract\CategoryInterface;
|
|
use App\Shared\Domain\Contract\SiteInterface;
|
|
use App\Shared\Domain\Contract\TimestampableInterface;
|
|
use App\Shared\Domain\Trait\TimestampableBlamableTrait;
|
|
use DateTimeImmutable;
|
|
use Doctrine\Common\Collections\ArrayCollection;
|
|
use Doctrine\Common\Collections\Collection;
|
|
use Doctrine\ORM\Mapping as ORM;
|
|
use Symfony\Component\Serializer\Attribute\Groups;
|
|
use Symfony\Component\Serializer\Attribute\SerializedName;
|
|
use Symfony\Component\Validator\Constraints as Assert;
|
|
use Symfony\Component\Validator\Context\ExecutionContextInterface;
|
|
|
|
/**
|
|
* Prestataire (M3 Technique) — entite racine du repertoire prestataires, jumelle
|
|
* du Fournisseur (M2). Porte le formulaire principal (nom + categories + sites),
|
|
* l'onglet Comptabilite, le mecanisme d'archivage (is_archived / archived_at) et
|
|
* le soft-delete technique prepare mais non expose au M3 (deleted_at, HP M4).
|
|
*
|
|
* Differences structurantes vs Supplier (cf. spec M3 § 3.1) :
|
|
* - PAS d'onglet Information : aucun champ description / competitors / founded_at
|
|
* / employees_count / revenue_amount / director_name / profit_amount /
|
|
* volume_forecast. Le prestataire est minimal : nom + comptabilite.
|
|
* - AJOUT de `sites` (M2M `provider_site`) : sites rattaches DIRECTEMENT au
|
|
* prestataire sur le formulaire principal (RG-3.03, >= 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';
|
|
|
|
/** Code pivot du type de reglement imposant une banque (RG-3.07). */
|
|
private const string PAYMENT_TYPE_VIREMENT = 'VIREMENT';
|
|
|
|
/** Code pivot du type de reglement imposant au moins un RIB (RG-3.08). */
|
|
private const string PAYMENT_TYPE_LCR = 'LCR';
|
|
|
|
#[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<int, CategoryInterface> */
|
|
#[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<int, SiteInterface> */
|
|
#[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<int, ProviderContact> */
|
|
#[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
|
private Collection $contacts;
|
|
|
|
/** @var Collection<int, ProviderAddress> */
|
|
#[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
|
private Collection $addresses;
|
|
|
|
/** @var Collection<int, ProviderRib> */
|
|
#[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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* RG-3.07 / RG-3.08 : coherence du type de reglement comptable. Comme au M2
|
|
* (decision figee ERP-89, jumeau Supplier::validatePaymentTypeConsistency),
|
|
* ces RG inter-champs passent par une contrainte d'entite (Assert\Callback +
|
|
* ->atPath()) et NON par le ProviderProcessor, afin que chaque 422 porte un
|
|
* propertyPath exploitable par extractApiViolations (mapping inline sous le
|
|
* champ, pas un toast — convention ERP-101).
|
|
* - RG-3.07 : paymentType = VIREMENT impose une banque -> violation sur `bank`.
|
|
* - RG-3.08 : paymentType = LCR impose au moins un RIB -> violation sur
|
|
* `paymentType` (les RIB n'ont pas de champ de formulaire ou s'ancrer quand
|
|
* la liste est vide ; l'erreur s'affiche donc sous le select « Type de
|
|
* règlement », binde cote front). Le 409 sur DELETE du dernier RIB en LCR est
|
|
* porte par le ProviderRibProcessor (ERP-135).
|
|
*
|
|
* Ces champs vivant dans le groupe d'ecriture comptable (absent du POST, qui
|
|
* n'expose que provider:write:main), la contrainte ne mord en pratique que sur
|
|
* le PATCH de l'onglet Comptabilite.
|
|
*/
|
|
#[Assert\Callback]
|
|
public function validatePaymentTypeConsistency(ExecutionContextInterface $context): void
|
|
{
|
|
$paymentCode = $this->paymentType?->getCode();
|
|
|
|
if (self::PAYMENT_TYPE_VIREMENT === $paymentCode && null === $this->bank) {
|
|
$context->buildViolation('La banque est obligatoire pour le type de règlement Virement.')
|
|
->atPath('bank')
|
|
->addViolation()
|
|
;
|
|
}
|
|
|
|
if (self::PAYMENT_TYPE_LCR === $paymentCode && $this->ribs->isEmpty()) {
|
|
$context->buildViolation('Au moins un RIB est obligatoire pour le type de règlement LCR.')
|
|
->atPath('paymentType')
|
|
->addViolation()
|
|
;
|
|
}
|
|
}
|
|
|
|
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<int, CategoryInterface> */
|
|
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<int, SiteInterface> */
|
|
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<int, ProviderContact> */
|
|
#[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<int, ProviderAddress> */
|
|
#[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<int, ProviderRib> */
|
|
#[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;
|
|
}
|
|
}
|