Matthieu
13d4a08bc9
Ecriture du formulaire principal transporteur (M4, WT4) : POST/PATCH via CarrierProcessor + CarrierFieldNormalizer, contraintes conditionnelles sur l'entite Carrier. - RG-4.01 : POST qualimatCarrier -> certificationType=QUALIMAT + FK persistee ; cas LIOT (name=LIOT) -> certification non requise, liotPlates accepte. - RG-4.02 : certificationType=AUTRE sans dischargeDocument -> 422 (Assert\Callback). - RG-4.03 : isChartered=true sans indexationRate/containerType/volumeM3 -> 422. - RG-4.12 : doublon de nom (parmi actifs) -> 409 (index partiel uq_carrier_name_active). - RG-4.13 : normalisation serveur (name UPPER, liotPlates ;-split/trim/UPPER) + methodes personne/telephone/email pour les sous-ressources Contact (WT7). - RG-4.14 : PATCH isArchived exige transport.carriers.archive (Admin seul), mode strict -> 403 + 422 si autre champ ; restauration en conflit -> 409. Operations Post/Patch ajoutees a l'ApiResource (lecture posee au WT3 conservee). RG conditionnelles portees par validateMainFormConsistency (Assert\Callback + ->atPath()) pour un propertyPath mappable inline (useFormErrors, ERP-101). certificationType / containerType whitelistes dans EXCLUDED_LENGTH_MIRROR (Choice borne deja les valeurs, miroir SupplierAddress::addressType). Tests : CarrierWriteApiTest (RG-4.01->4.03/4.12->4.14), CarrierRBACMatrixTest (matrice bureau/compta/commerciale/usine), CarrierArchiveTest (409 restauration), CarrierFieldNormalizerTest (RG-4.13). make test vert (750).
526 lines
19 KiB
PHP
526 lines
19 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Module\Transport\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\Transport\Infrastructure\ApiPlatform\State\Processor\CarrierProcessor;
|
|
use App\Module\Transport\Infrastructure\ApiPlatform\State\Provider\CarrierProvider;
|
|
use App\Module\Transport\Infrastructure\Doctrine\DoctrineCarrierRepository;
|
|
use App\Shared\Domain\Attribute\Auditable;
|
|
use App\Shared\Domain\Contract\BlamableInterface;
|
|
use App\Shared\Domain\Contract\TimestampableInterface;
|
|
use App\Shared\Domain\Entity\UploadedDocument;
|
|
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;
|
|
|
|
/**
|
|
* Transporteur (M4 Transport) — entite racine du repertoire transporteurs,
|
|
* jumelle de Supplier (M2) / Provider (M3). Porte le formulaire principal, le
|
|
* lien editable vers le referentiel QUALIMAT (§ 2.5), l'archivage
|
|
* (is_archived / archived_at) et le soft-delete technique prepare mais non
|
|
* expose au M4 (deleted_at).
|
|
*
|
|
* Perimetre WT4 (ERP-158) = formulaire principal en ecriture. L'#[ApiResource]
|
|
* expose desormais Post + Patch (via CarrierProcessor : normalisation RG-4.13,
|
|
* gating archive mode strict RG-4.14, 409 doublon de nom RG-4.12) en plus du
|
|
* contrat de lecture pose au WT3. Les proprietes du formulaire principal portent
|
|
* leur groupe d'ecriture (carrier:write:main / carrier:write:archive) et leurs
|
|
* contraintes Assert ; les RG conditionnelles (RG-4.01 certification obligatoire
|
|
* sauf LIOT, RG-4.02 AUTRE -> decharge, RG-4.03 affrete -> indexation/benne/volume)
|
|
* sont portees par validateMainFormConsistency (Assert\Callback + ->atPath()).
|
|
* Les sous-ressources d'ecriture (adresses/contacts/prix) arrivent aux worktrees
|
|
* suivants (WT6/7/8). Les invariants BDD (NOT NULL, CHECK enum, FK, unicite
|
|
* partielle) restent garantis par la migration Version20260615150000.
|
|
*
|
|
* Contrat de serialisation (RETEX M1, 3 maillons — spec § 4.0) :
|
|
* - LISTE (carrier:read + qualimat:read + default:read) : name, certificationType,
|
|
* qualimatCarrier (statut/validite — RG-4.04), updatedAt.
|
|
* - DETAIL (+ carrier:item:read + embeds client/supplier/site...) : sous-collections
|
|
* addresses / contacts / prices embarquees, avec les entites cross-module
|
|
* (Client/Supplier/Site/adresses) serialisees via leurs read-groups.
|
|
*
|
|
* Pas de #[ORM\UniqueConstraint] : l'unicite du nom (RG-4.12) est portee par
|
|
* l'index partiel fonctionnel uq_carrier_name_active (LOWER(name) WHERE
|
|
* is_archived = FALSE AND deleted_at IS NULL), inexprimable en attribut ORM.
|
|
*/
|
|
#[ApiResource(
|
|
operations: [
|
|
new GetCollection(
|
|
security: "is_granted('transport.carriers.view')",
|
|
// Liste : embarque qualimatCarrier (ManyToOne, fetch-join sur cette
|
|
// seule relation cote repository — § 2.11) pour le statut/date de
|
|
// validite QUALIMAT (RG-4.04). Aucune sous-collection en liste.
|
|
normalizationContext: ['groups' => ['carrier:read', 'qualimat:read', 'default:read']],
|
|
provider: CarrierProvider::class,
|
|
),
|
|
new Get(
|
|
security: "is_granted('transport.carriers.view')",
|
|
// Detail : transporteur + qualimatCarrier + sous-collections embarquees
|
|
// (addresses / contacts / prices). Les relations cross-module des prix
|
|
// (client / supplier / sites / adresses) sont embarquees via leurs
|
|
// read-groups (client:read / supplier:read / ... — bugs #1/#2 M1).
|
|
normalizationContext: ['groups' => [
|
|
'carrier:read',
|
|
'carrier:item:read',
|
|
'qualimat:read',
|
|
'client:read',
|
|
'client_address:read',
|
|
'supplier:read',
|
|
'supplier_address:read',
|
|
'site:read',
|
|
'default:read',
|
|
]],
|
|
provider: CarrierProvider::class,
|
|
),
|
|
new Post(
|
|
// Creation du formulaire principal (RG-4.01 -> RG-4.03 / RG-4.12 /
|
|
// RG-4.13). La reponse 201 ne renvoie que les scalaires principaux +
|
|
// id : le front enchaine ensuite les sous-ressources par onglet.
|
|
security: "is_granted('transport.carriers.manage')",
|
|
normalizationContext: ['groups' => ['carrier:read', 'default:read']],
|
|
denormalizationContext: ['groups' => ['carrier:write:main']],
|
|
processor: CarrierProcessor::class,
|
|
),
|
|
new Patch(
|
|
// Security elargie au seul `manage` (Admin + Bureau). Le CarrierProcessor
|
|
// re-gate ensuite l'archivage : un payload basculant isArchived exige
|
|
// `transport.carriers.archive` (Admin seul -> Bureau recoit 403, mode
|
|
// strict RG-4.14).
|
|
security: "is_granted('transport.carriers.manage')",
|
|
normalizationContext: ['groups' => ['carrier:read', 'default:read']],
|
|
denormalizationContext: ['groups' => ['carrier:write:main', 'carrier:write:archive']],
|
|
provider: CarrierProvider::class,
|
|
processor: CarrierProcessor::class,
|
|
),
|
|
// Pas de Delete au M4 (HP-M4-C). Archivage via PATCH { isArchived: true }.
|
|
],
|
|
)]
|
|
#[ORM\Entity(repositoryClass: DoctrineCarrierRepository::class)]
|
|
#[ORM\Table(name: 'carrier')]
|
|
#[ORM\Index(name: 'idx_carrier_is_archived', columns: ['is_archived'])]
|
|
#[ORM\Index(name: 'idx_carrier_deleted_at', columns: ['deleted_at'])]
|
|
#[ORM\Index(name: 'idx_carrier_qualimat', columns: ['qualimat_carrier_id'])]
|
|
#[ORM\Index(name: 'idx_carrier_discharge_document', columns: ['discharge_document_id'])]
|
|
#[ORM\Index(name: 'idx_carrier_created_by', columns: ['created_by'])]
|
|
#[ORM\Index(name: 'idx_carrier_updated_by', columns: ['updated_by'])]
|
|
#[Auditable]
|
|
class Carrier implements TimestampableInterface, BlamableInterface
|
|
{
|
|
use TimestampableBlamableTrait;
|
|
|
|
/** RG-4.01 : nom du cas special « compte-propre » LIOT (comparaison insensible a la casse). */
|
|
private const string LIOT_NAME = 'LIOT';
|
|
|
|
/** RG-4.02 : valeur de certification imposant le champ Decharge. */
|
|
private const string CERTIFICATION_AUTRE = 'AUTRE';
|
|
|
|
#[ORM\Id]
|
|
#[ORM\GeneratedValue]
|
|
#[ORM\Column]
|
|
#[Groups(['carrier:read'])]
|
|
private ?int $id = null;
|
|
|
|
#[ORM\Column(length: 255)]
|
|
#[Assert\NotBlank(message: 'Le nom du transporteur est obligatoire.', normalizer: 'trim')]
|
|
#[Assert\Length(
|
|
min: 2,
|
|
max: 255,
|
|
minMessage: 'Le nom du transporteur doit contenir au moins {{ limit }} caractères.',
|
|
maxMessage: 'Le nom du transporteur ne peut dépasser {{ limit }} caractères.',
|
|
normalizer: 'trim',
|
|
)]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $name = null;
|
|
|
|
/** Lien editable vers le referentiel QUALIMAT (saisie assistee RG-4.01, § 2.5). */
|
|
#[ORM\ManyToOne(targetEntity: QualimatCarrier::class)]
|
|
#[ORM\JoinColumn(name: 'qualimat_carrier_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?QualimatCarrier $qualimatCarrier = null;
|
|
|
|
/** QUALIMAT|GMP_PLUS|OVOCOM|COMPTE_PROPRE|AUTRE ; null en cas LIOT (RG-4.01). */
|
|
#[ORM\Column(length: 20, nullable: true)]
|
|
#[Assert\Choice(
|
|
choices: ['QUALIMAT', 'GMP_PLUS', 'OVOCOM', 'COMPTE_PROPRE', 'AUTRE'],
|
|
message: 'Type de certification invalide.',
|
|
)]
|
|
// Obligatoire SAUF en cas LIOT (champ masque) : controle conditionnel dans
|
|
// validateMainFormConsistency (RG-4.01). La longueur est bornee par le Choice
|
|
// (whitelist EntityConstraintsHaveFrenchMessageTest::EXCLUDED_LENGTH_MIRROR).
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $certificationType = null;
|
|
|
|
#[ORM\Column(name: 'is_chartered', options: ['default' => false])]
|
|
#[Groups(['carrier:write:main'])]
|
|
private bool $isChartered = false;
|
|
|
|
/** % d'indexation — obligatoire si affrete (RG-4.03, validateMainFormConsistency). */
|
|
#[ORM\Column(name: 'indexation_rate', type: 'decimal', precision: 5, scale: 2, nullable: true)]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $indexationRate = null;
|
|
|
|
/** BENNE|FOND_MOUVANT — obligatoire si affrete (RG-4.03). */
|
|
#[ORM\Column(name: 'container_type', length: 12, nullable: true)]
|
|
#[Assert\Choice(choices: ['BENNE', 'FOND_MOUVANT'], message: 'Type de contenant invalide.')]
|
|
// Longueur bornee par le Choice (whitelist EXCLUDED_LENGTH_MIRROR).
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $containerType = null;
|
|
|
|
/** Volume m3 — obligatoire si affrete (RG-4.03). */
|
|
#[ORM\Column(name: 'volume_m3', type: 'decimal', precision: 10, scale: 2, nullable: true)]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $volumeM3 = null;
|
|
|
|
/** Decharge (upload, visible si certificationType = AUTRE — RG-4.02). Infra Shared (§ 2.7). */
|
|
#[ORM\ManyToOne(targetEntity: UploadedDocument::class)]
|
|
#[ORM\JoinColumn(name: 'discharge_document_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?UploadedDocument $dischargeDocument = null;
|
|
|
|
/** Immatriculations LIOT separees par « ; » (cas LIOT — RG-4.01). */
|
|
#[ORM\Column(name: 'liot_plates', type: 'text', nullable: true)]
|
|
#[Groups(['carrier:read', 'carrier:write:main'])]
|
|
private ?string $liotPlates = null;
|
|
|
|
// === Sous-collections — EMBARQUEES dans le DETAIL (read-group sur le getter) ===
|
|
/** @var Collection<int, CarrierAddress> */
|
|
#[ORM\OneToMany(mappedBy: 'carrier', targetEntity: CarrierAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
|
private Collection $addresses;
|
|
|
|
/** @var Collection<int, CarrierContact> */
|
|
#[ORM\OneToMany(mappedBy: 'carrier', targetEntity: CarrierContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
|
private Collection $contacts;
|
|
|
|
/** @var Collection<int, CarrierPrice> */
|
|
#[ORM\OneToMany(mappedBy: 'carrier', targetEntity: CarrierPrice::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
|
private Collection $prices;
|
|
|
|
// === Archive / Soft delete ===
|
|
// Le groupe de LECTURE est declare sur le getter isArchived() avec
|
|
// SerializedName('isArchived') (piege booleen #3 M1) ; le groupe d'ECRITURE
|
|
// vit sur la propriete pour que la denormalisation cible setIsArchived.
|
|
#[ORM\Column(name: 'is_archived', options: ['default' => false])]
|
|
#[Groups(['carrier:write:archive'])]
|
|
private bool $isArchived = false;
|
|
|
|
#[ORM\Column(name: 'archived_at', type: 'datetime_immutable', nullable: true)]
|
|
#[Groups(['carrier:read'])]
|
|
private ?DateTimeImmutable $archivedAt = null;
|
|
|
|
#[ORM\Column(name: 'deleted_at', type: 'datetime_immutable', nullable: true)]
|
|
private ?DateTimeImmutable $deletedAt = null;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->addresses = new ArrayCollection();
|
|
$this->contacts = new ArrayCollection();
|
|
$this->prices = new ArrayCollection();
|
|
}
|
|
|
|
/**
|
|
* Coherence conditionnelle du formulaire principal (RG-4.01 / RG-4.02 /
|
|
* RG-4.03). Decision figee (miroir M2 RG-2.07/2.08) : ces RG inter-champs
|
|
* passent par une contrainte d'entite (Assert\Callback + ->atPath()) et NON par
|
|
* le CarrierProcessor, afin que chaque 422 porte un propertyPath exploitable
|
|
* par useFormErrors (mapping inline sous le champ, pas un toast — ERP-101).
|
|
* Jouee par API Platform AVANT le processor, sur POST comme sur PATCH.
|
|
*
|
|
* Cas LIOT (RG-4.01) : seul liotPlates est pertinent ; les autres champs sont
|
|
* masques cote front et le back ne les valide pas (« stocke ce qu'il recoit,
|
|
* pas de 422 sur la presence residuelle »). Le nom est compare en majuscules
|
|
* car la normalisation UPPER n'intervient qu'au processor (apres validation).
|
|
*/
|
|
#[Assert\Callback]
|
|
public function validateMainFormConsistency(ExecutionContextInterface $context): void
|
|
{
|
|
if (self::LIOT_NAME === mb_strtoupper(trim((string) $this->name), 'UTF-8')) {
|
|
return;
|
|
}
|
|
|
|
// RG-4.01 : certification obligatoire hors cas LIOT.
|
|
if (null === $this->certificationType || '' === $this->certificationType) {
|
|
$context->buildViolation('Le type de certification est obligatoire.')
|
|
->atPath('certificationType')
|
|
->addViolation()
|
|
;
|
|
}
|
|
|
|
// RG-4.02 : certification AUTRE -> decharge obligatoire.
|
|
if (self::CERTIFICATION_AUTRE === $this->certificationType && null === $this->dischargeDocument) {
|
|
$context->buildViolation('La décharge est obligatoire pour une certification « Autre ».')
|
|
->atPath('dischargeDocument')
|
|
->addViolation()
|
|
;
|
|
}
|
|
|
|
// RG-4.03 : affrete -> indexation + benne/fond mouvant + volume obligatoires.
|
|
if ($this->isChartered) {
|
|
if (null === $this->indexationRate) {
|
|
$context->buildViolation('Le taux d\'indexation est obligatoire pour un transporteur affrété.')
|
|
->atPath('indexationRate')
|
|
->addViolation()
|
|
;
|
|
}
|
|
if (null === $this->containerType) {
|
|
$context->buildViolation('Le type de contenant est obligatoire pour un transporteur affrété.')
|
|
->atPath('containerType')
|
|
->addViolation()
|
|
;
|
|
}
|
|
if (null === $this->volumeM3) {
|
|
$context->buildViolation('Le volume est obligatoire pour un transporteur affrété.')
|
|
->atPath('volumeM3')
|
|
->addViolation()
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getId(): ?int
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
public function getName(): ?string
|
|
{
|
|
return $this->name;
|
|
}
|
|
|
|
public function setName(string $name): static
|
|
{
|
|
$this->name = $name;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getQualimatCarrier(): ?QualimatCarrier
|
|
{
|
|
return $this->qualimatCarrier;
|
|
}
|
|
|
|
public function setQualimatCarrier(?QualimatCarrier $qualimatCarrier): static
|
|
{
|
|
$this->qualimatCarrier = $qualimatCarrier;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getCertificationType(): ?string
|
|
{
|
|
return $this->certificationType;
|
|
}
|
|
|
|
public function setCertificationType(?string $certificationType): static
|
|
{
|
|
$this->certificationType = $certificationType;
|
|
|
|
return $this;
|
|
}
|
|
|
|
// Boolean trap (RETEX M1 bug #3) : #[Groups] + #[SerializedName] sur le getter,
|
|
// sinon Symfony strip le prefixe "is" et drope la cle du JSON.
|
|
#[Groups(['carrier:read'])]
|
|
#[SerializedName('isChartered')]
|
|
public function isChartered(): bool
|
|
{
|
|
return $this->isChartered;
|
|
}
|
|
|
|
public function setIsChartered(bool $isChartered): static
|
|
{
|
|
$this->isChartered = $isChartered;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getIndexationRate(): ?string
|
|
{
|
|
return $this->indexationRate;
|
|
}
|
|
|
|
public function setIndexationRate(?string $indexationRate): static
|
|
{
|
|
$this->indexationRate = $indexationRate;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getContainerType(): ?string
|
|
{
|
|
return $this->containerType;
|
|
}
|
|
|
|
public function setContainerType(?string $containerType): static
|
|
{
|
|
$this->containerType = $containerType;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getVolumeM3(): ?string
|
|
{
|
|
return $this->volumeM3;
|
|
}
|
|
|
|
public function setVolumeM3(?string $volumeM3): static
|
|
{
|
|
$this->volumeM3 = $volumeM3;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDischargeDocument(): ?UploadedDocument
|
|
{
|
|
return $this->dischargeDocument;
|
|
}
|
|
|
|
public function setDischargeDocument(?UploadedDocument $dischargeDocument): static
|
|
{
|
|
$this->dischargeDocument = $dischargeDocument;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getLiotPlates(): ?string
|
|
{
|
|
return $this->liotPlates;
|
|
}
|
|
|
|
public function setLiotPlates(?string $liotPlates): static
|
|
{
|
|
$this->liotPlates = $liotPlates;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/** @return Collection<int, CarrierAddress> */
|
|
#[Groups(['carrier:item:read'])]
|
|
public function getAddresses(): Collection
|
|
{
|
|
return $this->addresses;
|
|
}
|
|
|
|
public function addAddress(CarrierAddress $address): static
|
|
{
|
|
if (!$this->addresses->contains($address)) {
|
|
$this->addresses->add($address);
|
|
$address->setCarrier($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeAddress(CarrierAddress $address): static
|
|
{
|
|
if ($this->addresses->removeElement($address) && $address->getCarrier() === $this) {
|
|
$address->setCarrier(null);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/** @return Collection<int, CarrierContact> */
|
|
#[Groups(['carrier:item:read'])]
|
|
public function getContacts(): Collection
|
|
{
|
|
return $this->contacts;
|
|
}
|
|
|
|
public function addContact(CarrierContact $contact): static
|
|
{
|
|
if (!$this->contacts->contains($contact)) {
|
|
$this->contacts->add($contact);
|
|
$contact->setCarrier($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeContact(CarrierContact $contact): static
|
|
{
|
|
if ($this->contacts->removeElement($contact) && $contact->getCarrier() === $this) {
|
|
$contact->setCarrier(null);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/** @return Collection<int, CarrierPrice> */
|
|
#[Groups(['carrier:item:read'])]
|
|
public function getPrices(): Collection
|
|
{
|
|
return $this->prices;
|
|
}
|
|
|
|
public function addPrice(CarrierPrice $price): static
|
|
{
|
|
if (!$this->prices->contains($price)) {
|
|
$this->prices->add($price);
|
|
$price->setCarrier($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removePrice(CarrierPrice $price): static
|
|
{
|
|
if ($this->prices->removeElement($price) && $price->getCarrier() === $this) {
|
|
$price->setCarrier(null);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
// Boolean trap (cf. isChartered) : groupe de lecture + SerializedName sur le getter.
|
|
#[Groups(['carrier: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;
|
|
}
|
|
}
|