src/Entity/Agency.php line 181

Open in your IDE?
  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.  * @ORM\Table(name="fs_agency")
  12.  * @ORM\Entity(repositoryClass="App\Repository\AgencyRepository")
  13.  */
  14. class Agency
  15. {
  16.     public function __toString(){
  17.         return $this->name;
  18.     }
  20.     public function displayInfo(){
  21.        return $this->name. " - ".$this->mainAddress()." - Tel: ".$this->getPhone()." - ".$this->getEmail();
  22.     }
  24.     public function canReserve(){
  25.         if($this->getGroup() == null)
  26.             return false;
  27.         return true;
  28.     }
  30.     public function canDelete(){
  31.         return true;
  32.     }
  34.     public function getIsActive()
  35.     {
  36.         if($this->isAdminActive)
  37.             return true;
  38.         return false;
  39.     }
  40.     
  41.     public function languagesNoApi()
  42.     {
  43.         $array = array();
  44.         foreach($this->languages as $language)
  45.             if($language->getSign() != 'api')
  46.                 array_push($array, $language);
  48.         return $array;
  49.     }
  50.     
  51.     public function mainAddress()
  52.     {
  53.         foreach($this->addresses as $address){
  54.             return $address;
  55.         }
  56.     }
  58.     public function getReserveAsByDealer($dealerId){
  59.         foreach($this->dealers as $jt){
  60.             if($jt->getDealer()->getId() == $dealerId)
  61.                 return $jt->getReserveAs();
  62.         }
  63.         return null;
  64.     }
  66.     /**
  67.      * @ORM\Column(name="id", type="bigint")
  68.      * @ORM\Id
  69.      * @ORM\GeneratedValue(strategy="AUTO")
  70.      */
  71.     protected $id;
  72.         
  73.     /**
  74.      * @ORM\Column(name="name", type="string", length=191)
  75.      */
  76.     protected $name;
  77.     
  78.     /**
  79.      * @ORM\Column(name="email", type="string", length=191)
  80.      */
  81.     protected $email;
  83.     /**
  84.      * @ORM\Column(name="phone", type="string", length=191)
  85.      */
  86.     protected $phone;
  88.     /**
  89.      * @ORM\Column(name="fiscal_code", type="string", length=191)
  90.      */
  91.     protected $fiscalCode;
  93.     /**
  94.      * @ORM\Column(name="vat", type="string", length=191)
  95.      */
  96.     protected $vat;
  97.     
  98.     /**
  99.      * @ORM\Column(name="vat_country", type="string", length=191)
  100.      */
  101.     protected $vatCountry;
  102.     
  103.     /**
  104.      * @ORM\Column(name="sdi", type="string", length=191)
  105.      */
  106.     protected $sdi;
  107.     
  108.     /**
  109.      * @ORM\Column(name="directory_path", type="string", length=191)
  110.      */
  111.     protected $directoryPath;
  113.     /**
  114.      * @ORM\Column(name="logo_path", type="string", length=191, nullable=true)
  115.      */
  116.     protected $logoPath;
  117.     
  118.     /**
  119.      * @ORM\Column(name="admin_access", type="boolean")
  120.      */
  121.     protected $adminAccess = false;
  122.     
  123.     /**
  124.      * @ORM\Column(name="admin_active", type="boolean")
  125.      */
  126.     protected $adminActive = true;
  127.     
  128.     /**
  129.      * @ORM\Column(name="is_first_access", type="boolean")
  130.      */
  131.     protected $firstAccess = true;
  133.     // ONE TO MANY
  134.         /**
  135.          * @ORM\OneToMany(targetEntity="App\Entity\JoinTableDealerAgency", mappedBy="agency")
  136.          */
  137.         private $dealers;
  138.         
  139.         /**
  140.          * @ORM\OneToMany(targetEntity="App\Entity\Address", mappedBy="agency")
  141.          */
  142.         private $addresses;
  143.         
  144.         /**
  145.          * @ORM\OneToMany(targetEntity="App\Entity\Contact", mappedBy="agency")
  146.          */
  147.         private $contacts;
  149.         /**
  150.          * @ORM\OneToMany(targetEntity="App\Entity\JoinTableAgencyUser", mappedBy="agency")
  151.          */
  152.         private $users;
  153.                 
  154.         /**
  155.          * @ORM\OneToMany(targetEntity="App\Entity\Reservation", mappedBy="agency")
  156.          */
  157.         private $reservations;
  159.         /**
  160.          * @ORM\OneToMany(targetEntity="App\Entity\ReservationFreeCabins", mappedBy="agency")
  161.          */
  162.         private $reservationFreeCabins;
  163.     //
  165.     // MANY TO ONE
  166.         /**
  167.          * @ORM\ManyToOne(targetEntity="App\Entity\AgencyGroup", inversedBy="agencies")
  168.          * @ORM\JoinColumn(name="group_id", referencedColumnName="id")
  169.          */
  170.         private $group;
  172.         public function __construct()
  173.         {
  174.             $this->dealers = new ArrayCollection();
  175.             $this->addresses = new ArrayCollection();
  176.             $this->contacts = new ArrayCollection();
  177.             $this->users = new ArrayCollection();
  178.             $this->reservations = new ArrayCollection();
  179.             $this->reservationFreeCabins = new ArrayCollection();
  180.             $this->suppliers = new ArrayCollection();
  181.             $this->licenses = new ArrayCollection();
  182.             $this->orders = new ArrayCollection();
  183.             $this->signalerForOrders = new ArrayCollection();
  184.             $this->investorForFeatures = new ArrayCollection();
  185.         }
  186.     //
  188.     public function getId(): ?string
  189.     {
  190.         return $this->id;
  191.     }
  193.     public function getName(): ?string
  194.     {
  195.         return $this->name;
  196.     }
  198.     public function setName(string $name): static
  199.     {
  200.         $this->name = $name;
  202.         return $this;
  203.     }
  205.     public function getEmail(): ?string
  206.     {
  207.         return $this->email;
  208.     }
  210.     public function setEmail(string $email): static
  211.     {
  212.         $this->email = $email;
  214.         return $this;
  215.     }
  217.     public function getPhone(): ?string
  218.     {
  219.         return $this->phone;
  220.     }
  222.     public function setPhone(string $phone): static
  223.     {
  224.         $this->phone = $phone;
  226.         return $this;
  227.     }
  229.     public function getFiscalCode(): ?string
  230.     {
  231.         return $this->fiscalCode;
  232.     }
  234.     public function setFiscalCode(string $fiscalCode): static
  235.     {
  236.         $this->fiscalCode = $fiscalCode;
  238.         return $this;
  239.     }
  241.     public function getVat(): ?string
  242.     {
  243.         return $this->vat;
  244.     }
  246.     public function setVat(string $vat): static
  247.     {
  248.         $this->vat = $vat;
  250.         return $this;
  251.     }
  253.     public function getVatCountry(): ?string
  254.     {
  255.         return $this->vatCountry;
  256.     }
  258.     public function setVatCountry(string $vatCountry): static
  259.     {
  260.         $this->vatCountry = $vatCountry;
  262.         return $this;
  263.     }
  265.     public function getSdi(): ?string
  266.     {
  267.         return $this->sdi;
  268.     }
  270.     public function setSdi(string $sdi): static
  271.     {
  272.         $this->sdi = $sdi;
  274.         return $this;
  275.     }
  277.     public function getDirectoryPath(): ?string
  278.     {
  279.         return $this->directoryPath;
  280.     }
  282.     public function setDirectoryPath(string $directoryPath): static
  283.     {
  284.         $this->directoryPath = $directoryPath;
  286.         return $this;
  287.     }
  289.     public function getLogoPath(): ?string
  290.     {
  291.         return $this->logoPath;
  292.     }
  294.     public function setLogoPath(?string $logoPath): static
  295.     {
  296.         $this->logoPath = $logoPath;
  298.         return $this;
  299.     }
  301.     public function isAdminAccess(): ?bool
  302.     {
  303.         return $this->adminAccess;
  304.     }
  306.     public function setAdminAccess(bool $adminAccess): static
  307.     {
  308.         $this->adminAccess = $adminAccess;
  310.         return $this;
  311.     }
  313.     public function isAdminActive(): ?bool
  314.     {
  315.         return $this->adminActive;
  316.     }
  318.     public function setAdminActive(bool $adminActive): static
  319.     {
  320.         $this->adminActive = $adminActive;
  322.         return $this;
  323.     }
  325.     public function isFirstAccess(): ?bool
  326.     {
  327.         return $this->firstAccess;
  328.     }
  330.     public function setFirstAccess(bool $firstAccess): static
  331.     {
  332.         $this->firstAccess = $firstAccess;
  334.         return $this;
  335.     }
  337.     /**
  338.      * @return Collection<int, JoinTableDealerAgency>
  339.      */
  340.     public function getDealers(): Collection
  341.     {
  342.         return $this->dealers;
  343.     }
  345.     public function addDealer(JoinTableDealerAgency $dealer): static
  346.     {
  347.         if (!$this->dealers->contains($dealer)) {
  348.             $this->dealers->add($dealer);
  349.             $dealer->setAgency($this);
  350.         }
  352.         return $this;
  353.     }
  355.     public function removeDealer(JoinTableDealerAgency $dealer): static
  356.     {
  357.         if ($this->dealers->removeElement($dealer)) {
  358.             // set the owning side to null (unless already changed)
  359.             if ($dealer->getAgency() === $this) {
  360.                 $dealer->setAgency(null);
  361.             }
  362.         }
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return Collection<int, Address>
  369.      */
  370.     public function getAddresses(): Collection
  371.     {
  372.         return $this->addresses;
  373.     }
  375.     public function addAddress(Address $address): static
  376.     {
  377.         if (!$this->addresses->contains($address)) {
  378.             $this->addresses->add($address);
  379.             $address->setAgency($this);
  380.         }
  382.         return $this;
  383.     }
  385.     public function removeAddress(Address $address): static
  386.     {
  387.         if ($this->addresses->removeElement($address)) {
  388.             // set the owning side to null (unless already changed)
  389.             if ($address->getAgency() === $this) {
  390.                 $address->setAgency(null);
  391.             }
  392.         }
  394.         return $this;
  395.     }
  397.     /**
  398.      * @return Collection<int, Contact>
  399.      */
  400.     public function getContacts(): Collection
  401.     {
  402.         return $this->contacts;
  403.     }
  405.     public function addContact(Contact $contact): static
  406.     {
  407.         if (!$this->contacts->contains($contact)) {
  408.             $this->contacts->add($contact);
  409.             $contact->setAgency($this);
  410.         }
  412.         return $this;
  413.     }
  415.     public function removeContact(Contact $contact): static
  416.     {
  417.         if ($this->contacts->removeElement($contact)) {
  418.             // set the owning side to null (unless already changed)
  419.             if ($contact->getAgency() === $this) {
  420.                 $contact->setAgency(null);
  421.             }
  422.         }
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return Collection<int, JoinTableAgencyUser>
  429.      */
  430.     public function getUsers(): Collection
  431.     {
  432.         return $this->users;
  433.     }
  435.     public function addUser(JoinTableAgencyUser $user): static
  436.     {
  437.         if (!$this->users->contains($user)) {
  438.             $this->users->add($user);
  439.             $user->setAgency($this);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeUser(JoinTableAgencyUser $user): static
  446.     {
  447.         if ($this->users->removeElement($user)) {
  448.             // set the owning side to null (unless already changed)
  449.             if ($user->getAgency() === $this) {
  450.                 $user->setAgency(null);
  451.             }
  452.         }
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection<int, Reservation>
  459.      */
  460.     public function getReservations(): Collection
  461.     {
  462.         return $this->reservations;
  463.     }
  465.     public function addReservation(Reservation $reservation): static
  466.     {
  467.         if (!$this->reservations->contains($reservation)) {
  468.             $this->reservations->add($reservation);
  469.             $reservation->setAgency($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeReservation(Reservation $reservation): static
  476.     {
  477.         if ($this->reservations->removeElement($reservation)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($reservation->getAgency() === $this) {
  480.                 $reservation->setAgency(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, ReservationFreeCabins>
  489.      */
  490.     public function getReservationFreeCabins(): Collection
  491.     {
  492.         return $this->reservationFreeCabins;
  493.     }
  495.     public function addReservationFreeCabin(ReservationFreeCabins $reservationFreeCabin): static
  496.     {
  497.         if (!$this->reservationFreeCabins->contains($reservationFreeCabin)) {
  498.             $this->reservationFreeCabins->add($reservationFreeCabin);
  499.             $reservationFreeCabin->setAgency($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeReservationFreeCabin(ReservationFreeCabins $reservationFreeCabin): static
  506.     {
  507.         if ($this->reservationFreeCabins->removeElement($reservationFreeCabin)) {
  508.             // set the owning side to null (unless already changed)
  509.             if ($reservationFreeCabin->getAgency() === $this) {
  510.                 $reservationFreeCabin->setAgency(null);
  511.             }
  512.         }
  514.         return $this;
  515.     }
  517.     public function getGroup(): ?AgencyGroup
  518.     {
  519.         return $this->group;
  520.     }
  522.     public function setGroup(?AgencyGroup $group): static
  523.     {
  524.         $this->group = $group;
  526.         return $this;
  527.     }
  528. }