src/Entity/Institution.php line 33

  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use App\Entity\Mapped\NamedEntity;
  9. use App\Repository\InstitutionRepository;
  10. use App\Validator\Constraint as CustomValidator;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\ORM\Mapping as ORM;
  13. use Symfony\Component\Validator\Constraints as Assert;
  15. #[ORM\Entity(
  16.     repositoryClass: InstitutionRepository::class
  17. )]
  18. #[ORM\Table(
  19.     name: 'institution'
  20. )]
  21. #[ApiResource(
  22.     collectionOperations: [],
  23.     itemOperations: ['get']
  24. )]
  25. #[CustomValidator\OIBFormat(
  26.     message: 'institution.oib.format',
  27.     groups: ['action']
  28. )]
  29. #[CustomValidator\OIBInstitutionUnique(
  30.     message: 'institution.oib.unique',
  31.     groups: ['action']
  32. )]
  33. class Institution extends NamedEntity implements DocumentOwnerInterface
  34. {
  35.     #[ORM\Column(
  36.         name: 'label',
  37.         type: 'string',
  38.         length: 191,
  39.         nullable: true
  40.     )]
  41.     #[Assert\NotBlank(
  42.         groups: ['action']
  43.     )]
  44.     #[Assert\Length(
  45.         max: 3,
  46.         groups: ['action']
  47.     )]
  48.     private ?string $label = null;
  50.     #[ORM\Column(
  51.         name: 'color',
  52.         type: 'string',
  53.         length: 191,
  54.         nullable: true
  55.     )]
  56.     #[Assert\NotBlank(
  57.         groups: ['action']
  58.     )]
  59.     #[Assert\Length(
  60.         max: 100,
  61.         groups: ['action']
  62.     )]
  63.     private ?string $color = null;
  65.     #[ORM\Column(
  66.         name: 'oib',
  67.         type: 'string',
  68.         length: 191,
  69.         nullable: true
  70.     )]
  71.     #[Assert\NotBlank(
  72.         groups: ['action']
  73.     )]
  74.     private ?string $oib = null;
  76.     #[ORM\Column(
  77.         name: 'address',
  78.         type: 'string',
  79.         length: 191,
  80.         nullable: true
  81.     )]
  82.     private ?string $address = null;
  84.     #[ORM\Column(
  85.         name: 'place',
  86.         type: 'string',
  87.         length: 191,
  88.         nullable: true
  89.     )]
  90.     private ?string $place = null;
  92.     #[ORM\Column(
  93.         name: 'country',
  94.         type: 'string',
  95.         length: 191,
  96.         nullable: true
  97.     )]
  98.     private ?string $country = null;
  100.     #[ORM\Column(
  101.         name: 'contact_phone',
  102.         type: 'string',
  103.         length: 191,
  104.         nullable: true
  105.     )]
  106.     private ?string $contactPhone = null;
  108.     #[ORM\Column(
  109.         name: 'contact_email',
  110.         type: 'string',
  111.         length: 191,
  112.         nullable: true
  113.     )]
  114.     private ?string $contactEmail = null;
  116.     #[ORM\Column(
  117.         name: 'web_page',
  118.         type: 'string',
  119.         length: 191,
  120.         nullable: true
  121.     )]
  122.     private ?string $webPage = null;
  124.     #[ORM\Column(
  125.         name: 'additional_data',
  126.         type: 'text',
  127.         nullable: true
  128.     )]
  129.     private ?string $additionalData = null;
  131.     #[ORM\Column(
  132.         name: 'is_pdv',
  133.         type: 'boolean',
  134.         nullable: true
  135.     )]
  136.     private ?bool $isPdv = false;
  138.     #[ORM\ManyToOne(
  139.         targetEntity: LegalEntity::class
  140.     )]
  141.     #[ORM\JoinColumn(
  142.         name: 'legal_entity'
  143.     )]
  144.     #[Assert\NotBlank(
  145.         groups: ['action']
  146.     )]
  147.     #[Assert\NotBlank(
  148.         groups: ['action']
  149.     )]
  150.     private ?LegalEntity $legalEntity = null;
  152.     #[ORM\OneToMany(
  153.         mappedBy: 'institution',
  154.         targetEntity: InstitutionContactPerson::class,
  155.         cascade: ['persist'],
  156.         fetch: 'EXTRA_LAZY',
  157.         orphanRemoval: true
  158.     )]
  159.     #[Assert\Valid(
  160.         groups: ['action']
  161.     )]
  162.     private iterable $contactPerson;
  164.     #[ORM\OneToMany(
  165.         mappedBy: 'institution',
  166.         targetEntity: InstitutionResponsiblePerson::class,
  167.         cascade: ['persist'],
  168.         fetch: 'EXTRA_LAZY',
  169.         orphanRemoval: true
  170.     )]
  171.     #[Assert\Valid(
  172.         groups: ['action']
  173.     )]
  174.     private iterable $responsiblePerson;
  176.     #[ORM\OneToMany(
  177.         mappedBy: 'institution',
  178.         targetEntity: InstitutionDocument::class,
  179.         cascade: ['persist'],
  180.         fetch: 'EXTRA_LAZY',
  181.         orphanRemoval: true
  182.     )]
  183.     #[Assert\Valid(
  184.         groups: ['action']
  185.     )]
  186.     private iterable $document;
  188.     #[ORM\OneToMany(
  189.         mappedBy: 'institution',
  190.         targetEntity: UserInstitution::class,
  191.         cascade: ['persist'],
  192.         fetch: 'EXTRA_LAZY',
  193.         orphanRemoval: true
  194.     )]
  195.     private iterable $userInstitution;
  197.     public function __construct()
  198.     {
  199.         $this->contactPerson = new ArrayCollection();
  200.         $this->responsiblePerson = new ArrayCollection();
  201.         $this->document = new ArrayCollection();
  202.         $this->userInstitution = new ArrayCollection();
  203.     }
  205.     public function getLabel(): ?string
  206.     {
  207.         return $this->label;
  208.     }
  210.     public function setLabel(?string $label): self
  211.     {
  212.         $this->label = $label;
  214.         return $this;
  215.     }
  217.     public function getColor(): ?string
  218.     {
  219.         return $this->color;
  220.     }
  222.     public function setColor(?string $color): self
  223.     {
  224.         $this->color = $color;
  226.         return $this;
  227.     }
  229.     public function getOib(): ?string
  230.     {
  231.         return $this->oib;
  232.     }
  234.     public function setOib(?string $oib): self
  235.     {
  236.         $this->oib = $oib;
  238.         return $this;
  239.     }
  241.     public function getAddress(): ?string
  242.     {
  243.         return $this->address;
  244.     }
  246.     public function setAddress(?string $address): self
  247.     {
  248.         $this->address = $address;
  250.         return $this;
  251.     }
  253.     public function getPlace(): ?string
  254.     {
  255.         return $this->place;
  256.     }
  258.     public function setPlace(?string $place): self
  259.     {
  260.         $this->place = $place;
  262.         return $this;
  263.     }
  265.     public function getCountry(): ?string
  266.     {
  267.         return $this->country;
  268.     }
  270.     public function setCountry(?string $country): self
  271.     {
  272.         $this->country = $country;
  274.         return $this;
  275.     }
  277.     public function getContactPhone(): ?string
  278.     {
  279.         return $this->contactPhone;
  280.     }
  282.     public function setContactPhone(?string $contactPhone): self
  283.     {
  284.         $this->contactPhone = $contactPhone;
  286.         return $this;
  287.     }
  289.     public function getContactEmail(): ?string
  290.     {
  291.         return $this->contactEmail;
  292.     }
  294.     public function setContactEmail(?string $contactEmail): self
  295.     {
  296.         $this->contactEmail = $contactEmail;
  298.         return $this;
  299.     }
  301.     public function getWebPage(): ?string
  302.     {
  303.         return $this->webPage;
  304.     }
  306.     public function setWebPage(?string $webPage): self
  307.     {
  308.         $this->webPage = $webPage;
  310.         return $this;
  311.     }
  313.     public function getAdditionalData(): ?string
  314.     {
  315.         return $this->additionalData;
  316.     }
  318.     public function setAdditionalData(?string $additionalData): self
  319.     {
  320.         $this->additionalData = $additionalData;
  322.         return $this;
  323.     }
  325.     public function getIsPdv(): ?bool
  326.     {
  327.         return $this->isPdv;
  328.     }
  330.     public function setIsPdv(?bool $isPdv): self
  331.     {
  332.         $this->isPdv = $isPdv;
  334.         return $this;
  335.     }
  337.     public function getUserInstitution(): iterable
  338.     {
  339.         return $this->userInstitution;
  340.     }
  342.     public function getLegalEntity(): ?LegalEntity
  343.     {
  344.         return $this->legalEntity;
  345.     }
  347.     public function setLegalEntity(?LegalEntity $legalEntity): self
  348.     {
  349.         $this->legalEntity = $legalEntity;
  351.         return $this;
  352.     }
  354.     public function getContactPerson(): iterable
  355.     {
  356.         return $this->contactPerson;
  357.     }
  359.     public function addContactPerson(InstitutionContactPerson $contactPerson): void
  360.     {
  361.         if ($this->contactPerson->contains($contactPerson)) {
  362.             return;
  363.         }
  364.         $this->contactPerson[] = $contactPerson;
  366.         $contactPerson->setInstitution($this);
  367.     }
  369.     public function removeContactPerson(InstitutionContactPerson $contactPerson): void
  370.     {
  371.         if (!$this->contactPerson->contains($contactPerson)) {
  372.             return;
  373.         }
  374.         $this->contactPerson->removeElement($contactPerson);
  376.         $contactPerson->setInstitution(null);
  377.     }
  379.     public function getResponsiblePerson(): iterable
  380.     {
  381.         return $this->responsiblePerson;
  382.     }
  384.     public function addResponsiblePerson(InstitutionResponsiblePerson $responsiblePerson): void
  385.     {
  386.         if ($this->responsiblePerson->contains($responsiblePerson)) {
  387.             return;
  388.         }
  389.         $this->responsiblePerson[] = $responsiblePerson;
  391.         $responsiblePerson->setInstitution($this);
  392.     }
  394.     public function removeResponsiblePerson(InstitutionResponsiblePerson $responsiblePerson): void
  395.     {
  396.         if (!$this->responsiblePerson->contains($responsiblePerson)) {
  397.             return;
  398.         }
  399.         $this->responsiblePerson->removeElement($responsiblePerson);
  401.         $responsiblePerson->setInstitution(null);
  402.     }
  404.     public function getDocument(): iterable
  405.     {
  406.         return $this->document;
  407.     }
  409.     public function addDocument(DocumentInterface $document): void
  410.     {
  411.         if ($this->document->contains($document)) {
  412.             return;
  413.         }
  414.         $this->document[] = $document;
  416.         $document->setInstitution($this);
  417.     }
  419.     public function removeDocument(DocumentInterface $document): void
  420.     {
  421.         if (!$this->document->contains($document)) {
  422.             return;
  423.         }
  424.         $this->document->removeElement($document);
  426.         $document->setInstitution(null);
  427.     }
  428. }