src/Entity/MappaCategorieArticoli.php line 47

  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\DBAL\Types\Types;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * MappaCategorieArticoli
  12.  *
  13.  * @ORM\Table(name="mappa_categorie_articoli", indexes={
  14.  *     @ORM\Index(name="mappa_cat_art_idx",
  15.  *     columns={
  16.  *      "articolo_id",
  17.  *      "categoria1_id",
  18.  *      "categoria2_id",
  19.  *      "categoria3_id",
  20.  *      "categoria4_id",
  21.  *      "categoria5_id",
  22.  *      "marca"
  23.  *     }),
  24.  *     @ORM\Index(name="mappa_marca_idx",
  25.  *     columns={
  26.  *      "marca"
  27.  *     }),
  28.  *     @ORM\Index(name="mappa_ordinamento_idx",
  29.  *     columns={
  30.  *      "ordinamento"
  31.  *     }),
  32.  *     @ORM\Index(name="mappa_attivo_idx",
  33.  *     columns={
  34.  *      "attivo"
  35.  *     }),
  36.  *     @ORM\Index(name="mappa_grp_cat_idx",
  37.  *     columns={
  38.  *      "codice_gruppo_categorie"
  39.  *     }),
  40.  *     @ORM\Index(name="mappa_disp_idx",
  41.  *     columns={
  42.  *      "disponibile"
  43.  *     })
  44.  * })
  45.  * @ORM\Entity(repositoryClass="App\Repository\MappaCategorieArticoliRepository")
  46.  */
  47. class MappaCategorieArticoli
  48. {
  49.     /**
  50.      * @var int
  51.      *
  52.      * @ORM\Column(name="id", type="integer")
  53.      * @ORM\Id
  54.      * @ORM\GeneratedValue(strategy="AUTO")
  55.      */
  56.     private $id;
  58.     /**
  59.      * @var int
  60.      *
  61.      * @ORM\Column(name="ordinamento", type="integer", nullable=true)
  62.      */
  63.     private $ordinamento;
  65.     /**
  66.      * @ORM\ManyToOne(targetEntity="Articoli")
  67.      * @ORM\JoinColumn(name="articolo_id", referencedColumnName="id", onDelete="SET NULL")
  68.      */
  69.     private $articolo;
  71.     /**
  72.      * @var bool
  73.      *
  74.      * @ORM\Column(name="attivo", type="boolean", nullable=true)
  75.      */
  76.     private $attivo;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity="App\Entity\AssociazioneArticoliTipoOrdine", mappedBy="mappaCategoriaArticolo", cascade={"remove"}, orphanRemoval=true)
  80.      */
  81.     private $associazioneArticoliTipoOrdine;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity="App\Entity\AssociazioneCategorieAlberoMappaCategorieArticoli", mappedBy="mappaCategoriaArticolo", cascade={"remove"}, orphanRemoval=true)
  85.      */
  86.     private $associazioneCategorieAlberoMappaCategorieArticoli;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity="App\Entity\MagazzinoSecondarioDisponibilita", mappedBy="mappaCategorieArticoli", cascade={"remove"}, orphanRemoval=true)
  90.      */
  91.     private $magazziniSecondariDisponibilita;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity="App\Entity\DisponibilitaAFasce", mappedBy="mappa_categoria_articolo", cascade={"remove"}, orphanRemoval=true)
  95.      */
  96.     private $disponibilitaAFasce;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity="App\Entity\ListiniVendita", mappedBy="mappaCategorieArticoli", cascade={"remove"}, orphanRemoval=true)
  100.      */
  101.     private $listiniVendita;
  103.     /**
  104.      * @ORM\ManyToOne(targetEntity="Categorie")
  105.      * @ORM\JoinColumn(name="categoria1_id", referencedColumnName="id", onDelete="SET NULL")
  106.      */
  107.     private $categoria1;
  109.     /**
  110.      * @ORM\ManyToOne(targetEntity="Categorie")
  111.      * @ORM\JoinColumn(name="categoria2_id", referencedColumnName="id", onDelete="SET NULL")
  112.      */
  113.     private $categoria2;
  115.     /**
  116.      * @ORM\ManyToOne(targetEntity="Categorie")
  117.      * @ORM\JoinColumn(name="categoria3_id", referencedColumnName="id", onDelete="SET NULL")
  118.      */
  119.     private $categoria3;
  121.     /**
  122.      * @ORM\ManyToOne(targetEntity="Categorie")
  123.      * @ORM\JoinColumn(name="categoria4_id", referencedColumnName="id", onDelete="SET NULL")
  124.      */
  125.     private $categoria4;
  127.     /**
  128.      * @ORM\ManyToOne(targetEntity="Categorie")
  129.      * @ORM\JoinColumn(name="categoria5_id", referencedColumnName="id", onDelete="SET NULL")
  130.      */
  131.     private $categoria5;
  133.     /**
  134.      * @var string
  135.      *
  136.      * @ORM\Column(name="marca", type="string", length=255, nullable=true)
  137.      */
  138.     private $marca;
  140.     /**
  141.      * @var string
  142.      *
  143.      * @ORM\Column(name="codice_gruppo_categorie", type="string", length=255, nullable=true)
  144.      */
  145.     private $codiceGruppoCategorie;
  147.     /**
  148.      * @var string
  149.      *
  150.      * @ORM\Column(name="disponibile", type="decimal", precision=20, scale=5, nullable=true)
  151.      */
  152.     private $disponibile;
  154.     /**
  155.      * @var string
  156.      *
  157.      * @ORM\Column(name="ordini_fornitori", type="decimal", precision=20, scale=5, nullable=true)
  158.      */
  159.     private $ordiniFornitori;
  161.     /**
  162.      * @ORM\OneToMany(targetEntity="App\Entity\AssociazioneArticoliCliente", mappedBy="mappaCategoriaArticoli", cascade={"remove"}, orphanRemoval=true)
  163.      */
  164.     private $associazioneArticoliClienti;
  166.     /**
  167.      * @ORM\OneToMany(targetEntity="App\Entity\AssociazioneAttributi", mappedBy="mappaCategoriaArticolo", cascade={"remove"}, orphanRemoval=true)
  168.      */
  169.     private $attributi;
  171.     /**
  172.      * @ORM\OneToMany(targetEntity="App\Entity\AssociazioneCategorieAlberoMappaCategorieArticoli", mappedBy="mappaCategoriaArticolo", cascade={"remove"}, orphanRemoval=true)
  173.      */
  174.     private $categorieAlbero;
  176.     /**
  177.      * @ORM\OneToMany(targetEntity="App\Entity\Varianti", mappedBy="mappa", cascade={"remove"}, orphanRemoval=true)
  178.      */
  179.     private $varianti;
  181.     /**
  182.      * @var bool
  183.      *
  184.      * @ORM\Column(name="varianti_presenti", type="boolean", nullable=true)
  185.      */
  186.     private $variantiPresenti;
  188.     /**
  189.      * @var \DateTime
  190.      *
  191.      * @ORM\Column(name="data_modifica", type="datetime")
  192.      */
  193.     private $dataModifica;
  195.     /**
  196.      * @var \DateTime
  197.      *
  198.      * @ORM\Column(name="data_creazione", type="datetime")
  199.      */
  200.     private $dataCreazione;
  202.     /**
  203.      * @ORM\ManyToOne(targetEntity="User")
  204.      * @ORM\JoinColumn(name="utente_id", referencedColumnName="id", onDelete="SET NULL")
  205.      */
  206.     private $utente;
  209.     /**
  210.      * Constructor
  211.      */
  212.     public function __construct()
  213.     {
  214.         $this->listiniVendita = new \Doctrine\Common\Collections\ArrayCollection();
  215.         $this->associazioneArticoliClienti = new \Doctrine\Common\Collections\ArrayCollection();
  216.         $this->attributi = new \Doctrine\Common\Collections\ArrayCollection();
  217.         $this->varianti = new \Doctrine\Common\Collections\ArrayCollection();
  218.         $this->associazioneArticoliTipoOrdine = new ArrayCollection();
  219.         $this->disponibilitaAFasce = new ArrayCollection();
  220.         $this->categorieAlbero = new ArrayCollection();
  221.         $this->associazioneCategorieAlberoMappaCategorieArticoli = new ArrayCollection();
  222.         $this->magazziniSecondariDisponibilita = new ArrayCollection();
  223.     }
  225.     public function getId(): ?int
  226.     {
  227.         return $this->id;
  228.     }
  230.     public function setMarca(?string $marca): static
  231.     {
  232.         $this->marca = $marca;
  234.         return $this;
  235.     }
  237.     public function getMarca(): ?string
  238.     {
  239.         return $this->marca;
  240.     }
  242.     public function setDataModifica(\DateTimeInterface $dataModifica): static
  243.     {
  244.         $this->dataModifica = $dataModifica;
  246.         return $this;
  247.     }
  249.     public function getDataModifica(): ?\DateTimeInterface
  250.     {
  251.         return $this->dataModifica;
  252.     }
  254.     public function setDataCreazione(\DateTimeInterface $dataCreazione): static
  255.     {
  256.         $this->dataCreazione = $dataCreazione;
  258.         return $this;
  259.     }
  261.     public function getDataCreazione(): ?\DateTimeInterface
  262.     {
  263.         return $this->dataCreazione;
  264.     }
  266.     public function setArticolo(?Articoli $articolo): static
  267.     {
  268.         $this->articolo = $articolo;
  270.         return $this;
  271.     }
  273.     public function getArticolo(): ?Articoli
  274.     {
  275.         return $this->articolo;
  276.     }
  278.     public function addListiniVenditum(ListiniVendita $listiniVenditum): static
  279.     {
  280.         if (!$this->listiniVendita->contains($listiniVenditum)) {
  281.             $this->listiniVendita->add($listiniVenditum);
  282.             $listiniVenditum->setMappaCategorieArticoli($this);
  283.         }
  285.         return $this;
  286.     }
  288.     public function removeListiniVenditum(ListiniVendita $listiniVenditum): static
  289.     {
  290.         if ($this->listiniVendita->removeElement($listiniVenditum)) {
  291.             // set the owning side to null (unless already changed)
  292.             if ($listiniVenditum->getMappaCategorieArticoli() === $this) {
  293.                 $listiniVenditum->setMappaCategorieArticoli(null);
  294.             }
  295.         }
  297.         return $this;
  298.     }
  300.     /**
  301.      * @return Collection<int, ListiniVendita>
  302.      */
  303.     public function getListiniVendita(): Collection
  304.     {
  305.         return $this->listiniVendita;
  306.     }
  308.     public function setCategoria1(?Categorie $categoria1): static
  309.     {
  310.         $this->categoria1 = $categoria1;
  312.         return $this;
  313.     }
  315.     public function getCategoria1(): ?Categorie
  316.     {
  317.         return $this->categoria1;
  318.     }
  320.     public function setCategoria2(?Categorie $categoria2): static
  321.     {
  322.         $this->categoria2 = $categoria2;
  324.         return $this;
  325.     }
  327.     public function getCategoria2(): ?Categorie
  328.     {
  329.         return $this->categoria2;
  330.     }
  332.     public function setCategoria3(?Categorie $categoria3): static
  333.     {
  334.         $this->categoria3 = $categoria3;
  336.         return $this;
  337.     }
  339.     public function getCategoria3(): ?Categorie
  340.     {
  341.         return $this->categoria3;
  342.     }
  344.     public function setCategoria4(?Categorie $categoria4): static
  345.     {
  346.         $this->categoria4 = $categoria4;
  348.         return $this;
  349.     }
  351.     public function getCategoria4(): ?Categorie
  352.     {
  353.         return $this->categoria4;
  354.     }
  356.     public function setCategoria5(?Categorie $categoria5): static
  357.     {
  358.         $this->categoria5 = $categoria5;
  360.         return $this;
  361.     }
  363.     public function getCategoria5(): ?Categorie
  364.     {
  365.         return $this->categoria5;
  366.     }
  368.     public function addAssociazioneArticoliClienti(AssociazioneArticoliCliente $associazioneArticoliClienti): static
  369.     {
  370.         if (!$this->associazioneArticoliClienti->contains($associazioneArticoliClienti)) {
  371.             $this->associazioneArticoliClienti->add($associazioneArticoliClienti);
  372.             $associazioneArticoliClienti->setMappaCategoriaArticoli($this);
  373.         }
  375.         return $this;
  376.     }
  378.     public function removeAssociazioneArticoliClienti(AssociazioneArticoliCliente $associazioneArticoliClienti): static
  379.     {
  380.         if ($this->associazioneArticoliClienti->removeElement($associazioneArticoliClienti)) {
  381.             // set the owning side to null (unless already changed)
  382.             if ($associazioneArticoliClienti->getMappaCategoriaArticoli() === $this) {
  383.                 $associazioneArticoliClienti->setMappaCategoriaArticoli(null);
  384.             }
  385.         }
  387.         return $this;
  388.     }
  390.     /**
  391.      * @return Collection<int, AssociazioneArticoliCliente>
  392.      */
  393.     public function getAssociazioneArticoliClienti(): Collection
  394.     {
  395.         return $this->associazioneArticoliClienti;
  396.     }
  398.     public function addAttributi(AssociazioneAttributi $attributi): static
  399.     {
  400.         if (!$this->attributi->contains($attributi)) {
  401.             $this->attributi->add($attributi);
  402.             $attributi->setMappaCategoriaArticolo($this);
  403.         }
  405.         return $this;
  406.     }
  408.     public function removeAttributi(AssociazioneAttributi $attributi): static
  409.     {
  410.         if ($this->attributi->removeElement($attributi)) {
  411.             // set the owning side to null (unless already changed)
  412.             if ($attributi->getMappaCategoriaArticolo() === $this) {
  413.                 $attributi->setMappaCategoriaArticolo(null);
  414.             }
  415.         }
  417.         return $this;
  418.     }
  420.     /**
  421.      * @return Collection<int, AssociazioneAttributi>
  422.      */
  423.     public function getAttributi(): Collection
  424.     {
  425.         return $this->attributi;
  426.     }
  428.     public function addVarianti(Varianti $varianti): static
  429.     {
  430.         if (!$this->varianti->contains($varianti)) {
  431.             $this->varianti->add($varianti);
  432.             $varianti->setMappa($this);
  433.         }
  435.         return $this;
  436.     }
  438.     public function removeVarianti(Varianti $varianti): static
  439.     {
  440.         if ($this->varianti->removeElement($varianti)) {
  441.             // set the owning side to null (unless already changed)
  442.             if ($varianti->getMappa() === $this) {
  443.                 $varianti->setMappa(null);
  444.             }
  445.         }
  447.         return $this;
  448.     }
  450.     /**
  451.      * @return Collection<int, Varianti>
  452.      */
  453.     public function getVarianti(): Collection
  454.     {
  455.         return $this->varianti;
  456.     }
  458.     public function setUtente(?User $utente): static
  459.     {
  460.         $this->utente = $utente;
  462.         return $this;
  463.     }
  465.     public function getUtente(): ?User
  466.     {
  467.         return $this->utente;
  468.     }
  470.     public function setDisponibile(?string $disponibile): static
  471.     {
  472.         $this->disponibile = $disponibile;
  474.         return $this;
  475.     }
  477.     public function getDisponibile(): ?string
  478.     {
  479.         return $this->disponibile;
  480.     }
  482.     public function setVariantiPresenti(?bool $variantiPresenti): static
  483.     {
  484.         $this->variantiPresenti = $variantiPresenti;
  486.         return $this;
  487.     }
  489.     public function getVariantiPresenti(): ?bool
  490.     {
  491.         return $this->variantiPresenti;
  492.     }
  494.     public function setOrdiniFornitori(?string $ordiniFornitori): static
  495.     {
  496.         $this->ordiniFornitori = $ordiniFornitori;
  498.         return $this;
  499.     }
  501.     public function getOrdiniFornitori(): ?string
  502.     {
  503.         return $this->ordiniFornitori;
  504.     }
  506.     /**
  507.      * @return Collection<int, AssociazioneArticoliTipoOrdine>
  508.      */
  509.     public function getAssociazioneArticoliTipoOrdine(): Collection
  510.     {
  511.         return $this->associazioneArticoliTipoOrdine;
  512.     }
  514.     public function addAssociazioneArticoliTipoOrdine(AssociazioneArticoliTipoOrdine $associazioneArticoliTipoOrdine): static
  515.     {
  516.         if (!$this->associazioneArticoliTipoOrdine->contains($associazioneArticoliTipoOrdine)) {
  517.             $this->associazioneArticoliTipoOrdine->add($associazioneArticoliTipoOrdine);
  518.             $associazioneArticoliTipoOrdine->setMappaCategoriaArticolo($this);
  519.         }
  521.         return $this;
  522.     }
  524.     public function removeAssociazioneArticoliTipoOrdine(AssociazioneArticoliTipoOrdine $associazioneArticoliTipoOrdine): static
  525.     {
  526.         if ($this->associazioneArticoliTipoOrdine->removeElement($associazioneArticoliTipoOrdine)) {
  527.             // set the owning side to null (unless already changed)
  528.             if ($associazioneArticoliTipoOrdine->getMappaCategoriaArticolo() === $this) {
  529.                 $associazioneArticoliTipoOrdine->setMappaCategoriaArticolo(null);
  530.             }
  531.         }
  533.         return $this;
  534.     }
  536.     /**
  537.      * @return Collection<int, DisponibilitaAFasce>
  538.      */
  539.     public function getDisponibilitaAFasce(): Collection
  540.     {
  541.         return $this->disponibilitaAFasce;
  542.     }
  544.     public function addDisponibilitaAFasce(DisponibilitaAFasce $disponibilitaAFasce): static
  545.     {
  546.         if (!$this->disponibilitaAFasce->contains($disponibilitaAFasce)) {
  547.             $this->disponibilitaAFasce->add($disponibilitaAFasce);
  548.             $disponibilitaAFasce->setMappaCategoriaArticolo($this);
  549.         }
  551.         return $this;
  552.     }
  554.     public function removeDisponibilitaAFasce(DisponibilitaAFasce $disponibilitaAFasce): static
  555.     {
  556.         if ($this->disponibilitaAFasce->removeElement($disponibilitaAFasce)) {
  557.             // set the owning side to null (unless already changed)
  558.             if ($disponibilitaAFasce->getMappaCategoriaArticolo() === $this) {
  559.                 $disponibilitaAFasce->setMappaCategoriaArticolo(null);
  560.             }
  561.         }
  563.         return $this;
  564.     }
  566.     public function getOrdinamento(): ?int
  567.     {
  568.         return $this->ordinamento;
  569.     }
  571.     public function setOrdinamento(?int $ordinamento): static
  572.     {
  573.         $this->ordinamento = $ordinamento;
  575.         return $this;
  576.     }
  578.     public function getAttivo(): ?bool
  579.     {
  580.         return $this->attivo;
  581.     }
  583.     public function setAttivo(?bool $attivo): static
  584.     {
  585.         $this->attivo = $attivo;
  587.         return $this;
  588.     }
  590.     public function getCodiceGruppoCategorie(): ?string
  591.     {
  592.         return $this->codiceGruppoCategorie;
  593.     }
  595.     public function setCodiceGruppoCategorie(?string $codiceGruppoCategorie): static
  596.     {
  597.         $this->codiceGruppoCategorie = $codiceGruppoCategorie;
  599.         return $this;
  600.     }
  602.     public function isAttivo(): ?bool
  603.     {
  604.         return $this->attivo;
  605.     }
  607.     public function isVariantiPresenti(): ?bool
  608.     {
  609.         return $this->variantiPresenti;
  610.     }
  612.     /**
  613.      * @return Collection<int, AssociazioneCategorieAlberoMappaCategorieArticoli>
  614.      */
  615.     public function getCategorieAlbero(): Collection
  616.     {
  617.         return $this->categorieAlbero;
  618.     }
  620.     public function addCategorieAlbero(AssociazioneCategorieAlberoMappaCategorieArticoli $categorieAlbero): static
  621.     {
  622.         if (!$this->categorieAlbero->contains($categorieAlbero)) {
  623.             $this->categorieAlbero->add($categorieAlbero);
  624.             $categorieAlbero->setMappaCategoriaArticolo($this);
  625.         }
  627.         return $this;
  628.     }
  630.     public function removeCategorieAlbero(AssociazioneCategorieAlberoMappaCategorieArticoli $categorieAlbero): static
  631.     {
  632.         if ($this->categorieAlbero->removeElement($categorieAlbero)) {
  633.             // set the owning side to null (unless already changed)
  634.             if ($categorieAlbero->getMappaCategoriaArticolo() === $this) {
  635.                 $categorieAlbero->setMappaCategoriaArticolo(null);
  636.             }
  637.         }
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return Collection<int, AssociazioneCategorieAlberoMappaCategorieArticoli>
  644.      */
  645.     public function getAssociazioneCategorieAlberoMappaCategorieArticoli(): Collection
  646.     {
  647.         return $this->associazioneCategorieAlberoMappaCategorieArticoli;
  648.     }
  650.     public function addAssociazioneCategorieAlberoMappaCategorieArticoli(AssociazioneCategorieAlberoMappaCategorieArticoli $associazioneCategorieAlberoMappaCategorieArticoli): static
  651.     {
  652.         if (!$this->associazioneCategorieAlberoMappaCategorieArticoli->contains($associazioneCategorieAlberoMappaCategorieArticoli)) {
  653.             $this->associazioneCategorieAlberoMappaCategorieArticoli->add($associazioneCategorieAlberoMappaCategorieArticoli);
  654.             $associazioneCategorieAlberoMappaCategorieArticoli->setMappaCategoriaArticolo($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removeAssociazioneCategorieAlberoMappaCategorieArticoli(AssociazioneCategorieAlberoMappaCategorieArticoli $associazioneCategorieAlberoMappaCategorieArticoli): static
  661.     {
  662.         if ($this->associazioneCategorieAlberoMappaCategorieArticoli->removeElement($associazioneCategorieAlberoMappaCategorieArticoli)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($associazioneCategorieAlberoMappaCategorieArticoli->getMappaCategoriaArticolo() === $this) {
  665.                 $associazioneCategorieAlberoMappaCategorieArticoli->setMappaCategoriaArticolo(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     /**
  673.      * @return Collection<int, MagazzinoSecondarioDisponibilita>
  674.      */
  675.     public function getMagazziniSecondariDisponibilita(): Collection
  676.     {
  677.         return $this->magazziniSecondariDisponibilita;
  678.     }
  680.     public function addMagazziniSecondariDisponibilitum(MagazzinoSecondarioDisponibilita $magazziniSecondariDisponibilitum): static
  681.     {
  682.         if (!$this->magazziniSecondariDisponibilita->contains($magazziniSecondariDisponibilitum)) {
  683.             $this->magazziniSecondariDisponibilita->add($magazziniSecondariDisponibilitum);
  684.             $magazziniSecondariDisponibilitum->setMappaCategorieArticoli($this);
  685.         }
  687.         return $this;
  688.     }
  690.     public function removeMagazziniSecondariDisponibilitum(MagazzinoSecondarioDisponibilita $magazziniSecondariDisponibilitum): static
  691.     {
  692.         if ($this->magazziniSecondariDisponibilita->removeElement($magazziniSecondariDisponibilitum)) {
  693.             // set the owning side to null (unless already changed)
  694.             if ($magazziniSecondariDisponibilitum->getMappaCategorieArticoli() === $this) {
  695.                 $magazziniSecondariDisponibilitum->setMappaCategorieArticoli(null);
  696.             }
  697.         }
  699.         return $this;
  700.     }
  701. }