src/Entity/Cliente.php line 11

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ClienteRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: ClienteRepository::class)]
  11. class Cliente
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column]
  16.     private ?int $id = null;
  18.     #[ORM\Column(length: 255)]
  19.     private ?string $nome = null;
  21.     #[ORM\Column(length: 255, nullable: true)]
  22.     private ?string $extraFields = null;
  24.     #[ORM\ManyToMany(targetEntity: User::class, inversedBy: 'clientes')]
  25.     private Collection $users;
  27.     #[ORM\ManyToMany(targetEntity: Caixa::class, mappedBy: 'clientes')]
  28.     private Collection $caixas;
  30.     #[ORM\OneToMany(mappedBy: 'cliente', targetEntity: Classificacao::class)]
  31.     private Collection $classificacaos;
  34.     #[ORM\OneToMany(mappedBy: 'cliente', targetEntity: Documento::class)]
  35.     private Collection $documentos;
  37.     #[ORM\OneToMany(mappedBy: 'cliente', targetEntity: Tipo::class)]
  38.     private Collection $tipos;
  40.     #[ORM\ManyToOne(inversedBy: 'clientes')]
  41.     private ?ClienteAll $clienteAll = null;
  43.     #[ORM\OneToMany(mappedBy: 'cliente', targetEntity: Fluxo::class)]
  44.     private Collection $fluxos;
  46.     public function __construct()
  47.     {
  48.         $this->users = new ArrayCollection();
  49.         $this->caixas = new ArrayCollection();
  50.         $this->classificacaos = new ArrayCollection();
  51.         $this->registros = new ArrayCollection();
  52.         $this->documentos = new ArrayCollection();
  53.         $this->tipos = new ArrayCollection();
  54.         $this->fluxos = new ArrayCollection();
  55.     }
  57.     public function getId(): ?int
  58.     {
  59.         return $this->id;
  60.     }
  62.     public function getNome(): ?string
  63.     {
  64.         return $this->nome;
  65.     }
  67.     public function setNome(string $nome): static
  68.     {
  69.         $this->nome = $nome;
  71.         return $this;
  72.     }
  74.     public function getExtraFields(): ?string
  75.     {
  76.         return $this->extraFields;
  77.     }
  79.     public function setExtraFields(?string $extraFields): static
  80.     {
  81.         $this->extraFields = $extraFields;
  83.         return $this;
  84.     }
  86.     /**
  87.      * @return Collection<int, User>
  88.      */
  89.     public function getUsers(): Collection
  90.     {
  91.         return $this->users;
  92.     }
  94.     public function addUser(User $user): static
  95.     {
  96.         if (!$this->users->contains($user)) {
  97.             $this->users->add($user);
  98.         }
  100.         return $this;
  101.     }
  103.     public function removeUser(User $user): static
  104.     {
  105.         $this->users->removeElement($user);
  107.         return $this;
  108.     }
  110.     /**
  111.      * @return Collection<int, Caixa>
  112.      */
  113.     public function getCaixas(): Collection
  114.     {
  115.         return $this->caixas;
  116.     }
  118.     public function addCaixa(Caixa $caixa): static
  119.     {
  120.         if (!$this->caixas->contains($caixa)) {
  121.             $this->caixas->add($caixa);
  122.             $caixa->addCliente($this);
  123.         }
  125.         return $this;
  126.     }
  128.     public function removeCaixa(Caixa $caixa): static
  129.     {
  130.         if ($this->caixas->removeElement($caixa)) {
  131.             $caixa->removeCliente($this);
  132.         }
  134.         return $this;
  135.     }
  137.     /**
  138.      * @return Collection<int, Classificacao>
  139.      */
  140.     public function getClassificacaos(): Collection
  141.     {
  142.         return $this->classificacaos;
  143.     }
  145.     public function addClassificacao(Classificacao $classificacao): static
  146.     {
  147.         if (!$this->classificacaos->contains($classificacao)) {
  148.             $this->classificacaos->add($classificacao);
  149.             $classificacao->setCliente($this);
  150.         }
  152.         return $this;
  153.     }
  155.     public function removeClassificacao(Classificacao $classificacao): static
  156.     {
  157.         if ($this->classificacaos->removeElement($classificacao)) {
  158.             // set the owning side to null (unless already changed)
  159.             if ($classificacao->getCliente() === $this) {
  160.                 $classificacao->setCliente(null);
  161.             }
  162.         }
  164.         return $this;
  165.     }
  167.   
  169.     /**
  170.      * @return Collection<int, Documento>
  171.      */
  172.     public function getDocumentos(): Collection
  173.     {
  174.         return $this->documentos;
  175.     }
  177.     public function addDocumento(Documento $documento): static
  178.     {
  179.         if (!$this->documentos->contains($documento)) {
  180.             $this->documentos->add($documento);
  181.             $documento->setCliente($this);
  182.         }
  184.         return $this;
  185.     }
  187.     public function removeDocumento(Documento $documento): static
  188.     {
  189.         if ($this->documentos->removeElement($documento)) {
  190.             // set the owning side to null (unless already changed)
  191.             if ($documento->getCliente() === $this) {
  192.                 $documento->setCliente(null);
  193.             }
  194.         }
  196.         return $this;
  197.     }
  199.     /**
  200.      * @return Collection<int, Tipo>
  201.      */
  202.     public function getTipos(): Collection
  203.     {
  204.         return $this->tipos;
  205.     }
  207.     public function addTipo(Tipo $tipo): static
  208.     {
  209.         if (!$this->tipos->contains($tipo)) {
  210.             $this->tipos->add($tipo);
  211.             $tipo->setCliente($this);
  212.         }
  214.         return $this;
  215.     }
  217.     public function removeTipo(Tipo $tipo): static
  218.     {
  219.         if ($this->tipos->removeElement($tipo)) {
  220.             // set the owning side to null (unless already changed)
  221.             if ($tipo->getCliente() === $this) {
  222.                 $tipo->setCliente(null);
  223.             }
  224.         }
  226.         return $this;
  227.     }
  229.     /**
  230.      * @return Collection<int, Fluxo>
  231.      */
  232.     public function getFluxos(): Collection
  233.     {
  234.         return $this->fluxos;
  235.     }
  237.     public function addFluxo(Fluxo $fluxo): static
  238.     {
  239.         if (!$this->fluxos->contains($fluxo)) {
  240.             $this->fluxos->add($fluxo);
  241.             $fluxo->setCliente($this);
  242.         }
  244.         return $this;
  245.     }
  247.     public function removeFluxo(Fluxo $fluxo): static
  248.     {
  249.         if ($this->fluxos->removeElement($fluxo)) {
  250.             // set the owning side to null (unless already changed)
  251.             if ($fluxo->getCliente() === $this) {
  252.                 $fluxo->setCliente(null);
  253.             }
  254.         }
  256.         return $this;
  257.     }
  259.     public function getClienteAll(): ?ClienteAll
  260.     {
  261.         return $this->clienteAll;
  262.     }
  264.     public function setClienteAll(?ClienteAll $clienteAll): static
  265.     {
  266.         $this->clienteAll = $clienteAll;
  268.         return $this;
  269.     }
  270. }