src/Entity/Entreprise.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EntrepriseRepository;
  6. use App\Traits\TimeStampTrait;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: EntrepriseRepository::class)]
  12. #[ORM\HasLifecycleCallbacks]
  13. class Entreprise
  14. {
  15.     use TimeStampTrait;
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 100)]
  23.     private ?string $code = null;
  25.     #[ORM\Column(length: 100)]
  26.     private ?string $name = null;
  28.     #[ORM\Column(length: 255, nullable: true)]
  29.     private ?string $adress = null;
  31.     #[ORM\Column(length: 100, nullable: true)]
  32.     private ?string $email = null;
  34.     #[ORM\Column(length: 50, nullable: true)]
  35.     private ?string $phone = null;
  37.     #[ORM\Column(length: 100, nullable: true)]
  38.     private ?string $pseudo = null;
  40.     #[ORM\Column(length: 255, nullable: true)]
  41.     private ?string $description = null;
  43.     #[ORM\Column(length: 50, nullable: true)]
  44.     private ?string $rccm = null;
  46.     #[ORM\Column(length: 100, nullable: true)]
  47.     private ?string $icon = null;
  49.     #[ORM\Column(nullable: true)]
  50.     private ?bool $status = null;
  52.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: User::class)]
  53.     private Collection $users;
  55.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Role::class)]
  56.     private Collection $roles;
  58.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CategoryResidence::class)]
  59.     private Collection $categoryResidences;
  61.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: ResidenceImmeuble::class)]
  62.     private Collection $residenceImmeubles;
  64.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: PaymentGenerator::class)]
  65.     private Collection $paymentGenerators;
  67.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Prestataire::class)]
  68.     private Collection $prestataires;
  70.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Incident::class)]
  71.     private Collection $incidents;
  73.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Template::class)]
  74.     private Collection $templates;
  76.     #[ORM\Column(nullable: true)]
  77.     private ?bool $smsservice = null;
  79.     #[ORM\Column(nullable: true)]
  80.     private ?bool $invoiceservice = null;
  82.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: PaymentGaranty::class)]
  83.     private Collection $paymentGaranties;
  85.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: IncidentUpdate::class)]
  86.     private Collection $incidentUpdates;
  88.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Service::class)]
  89.     private Collection $services;
  91.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
  92.     private ?Admin $admin = null;
  94.     #[ORM\Column(length: 50, nullable: true)]
  95.     private ?string $idnat = null;
  97.     #[ORM\Column(length: 50, nullable: true)]
  98.     private ?string $numeroimpot = null;
  100.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
  101.     private ?Country $country = null;
  103.     #[ORM\Column(length: 50, nullable: true)]
  104.     private ?string $city = null;
  106.     #[ORM\Column(length: 50, nullable: true)]
  107.     private ?string $province = null;
  109.     #[ORM\Column(nullable: true)]
  110.     private ?int $nbrebiensimmobiliers = null;
  112.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Subscription::class)]
  113.     private Collection $subscriptions;
  115.     #[ORM\Column(nullable: true)]
  116.     private ?bool $freeTrail = null;
  118.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
  119.     private ?Package $package = null;
  121.     #[ORM\Column(length: 25, nullable: true)]
  122.     private ?string $period = null;
  124.     #[ORM\Column]
  125.     private ?bool $recallpaymentnotification = null;
  127.     #[ORM\Column(length: 255, nullable: true)]
  128.     private ?string $smartPaykey = null;
  130.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Announcement::class)]
  131.     private Collection $announcements;
  133.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CashJournal::class)]
  134.     private Collection $cashJournals;
  136.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CashJournalEntry::class)]
  137.     private Collection $cashJournalEntries;
  139.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Charge::class)]
  140.     private Collection $charges;
  142.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: ChargeAllocation::class)]
  143.     private Collection $chargeAllocations;
  145.     #[ORM\Column(nullable: true)]
  146.     private ?bool $makeJournal = null;
  148.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Log::class)]
  149.     private Collection $logs;
  151.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Reservation::class)]
  152.     private Collection $reservations;
  154.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: UserEntreprise::class)]
  155.     private Collection $userEntreprises;
  157.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
  158.     private ?User $owner = null;
  160.     public function __construct()
  161.     {
  162.         $this->users = new ArrayCollection();
  163.         $this->roles = new ArrayCollection();
  164.         $this->categoryResidences = new ArrayCollection();
  165.         $this->residenceImmeubles = new ArrayCollection();
  166.         $this->paymentGenerators = new ArrayCollection();
  167.         $this->prestataires = new ArrayCollection();
  168.         $this->incidents = new ArrayCollection();
  169.         $this->templates = new ArrayCollection();
  170.         $this->paymentGaranties = new ArrayCollection();
  171.         $this->incidentUpdates = new ArrayCollection();
  172.         $this->services = new ArrayCollection();
  173.         $this->subscriptions = new ArrayCollection();
  174.         $this->announcements = new ArrayCollection();
  175.         $this->cashJournals = new ArrayCollection();
  176.         $this->cashJournalEntries = new ArrayCollection();
  177.         $this->charges = new ArrayCollection();
  178.         $this->chargeAllocations = new ArrayCollection();
  179.         $this->logs = new ArrayCollection();
  180.         $this->reservations = new ArrayCollection();
  181.         $this->userEntreprises = new ArrayCollection();
  182.     }
  184.     public function getId(): ?int
  185.     {
  186.         return $this->id;
  187.     }
  189.     public function getCode(): ?string
  190.     {
  191.         return $this->code;
  192.     }
  194.     public function setCode(string $code): static
  195.     {
  196.         $this->code = $code;
  198.         return $this;
  199.     }
  201.     public function getName(): ?string
  202.     {
  203.         return $this->name;
  204.     }
  206.     public function setName(string $name): static
  207.     {
  208.         $this->name = $name;
  210.         return $this;
  211.     }
  213.     public function getAdress(): ?string
  214.     {
  215.         return $this->adress;
  216.     }
  218.     public function setAdress(?string $adress): static
  219.     {
  220.         $this->adress = $adress;
  222.         return $this;
  223.     }
  225.     public function getEmail(): ?string
  226.     {
  227.         return $this->email;
  228.     }
  230.     public function setEmail(?string $email): static
  231.     {
  232.         $this->email = $email;
  234.         return $this;
  235.     }
  237.     public function getPhone(): ?string
  238.     {
  239.         return $this->phone;
  240.     }
  242.     public function setPhone(?string $phone): static
  243.     {
  244.         $this->phone = $phone;
  246.         return $this;
  247.     }
  249.     public function getPseudo(): ?string
  250.     {
  251.         return $this->pseudo;
  252.     }
  254.     public function setPseudo(?string $pseudo): static
  255.     {
  256.         $this->pseudo = $pseudo;
  258.         return $this;
  259.     }
  261.     public function getDescription(): ?string
  262.     {
  263.         return $this->description;
  264.     }
  266.     public function setDescription(?string $description): static
  267.     {
  268.         $this->description = $description;
  270.         return $this;
  271.     }
  273.     public function getRccm(): ?string
  274.     {
  275.         return $this->rccm;
  276.     }
  278.     public function setRccm(?string $rccm): static
  279.     {
  280.         $this->rccm = $rccm;
  282.         return $this;
  283.     }
  285.     public function getIcon(): ?string
  286.     {
  287.         return $this->icon;
  288.     }
  290.     public function setIcon(?string $icon): static
  291.     {
  292.         $this->icon = $icon;
  294.         return $this;
  295.     }
  297.     public function isStatus(): ?bool
  298.     {
  299.         return $this->status;
  300.     }
  302.     public function setStatus(?bool $status): static
  303.     {
  304.         $this->status = $status;
  306.         return $this;
  307.     }
  310.     public function __toString(): string
  311.     {
  312.         return $this->name;
  313.     }
  315.     /**
  316.      * @return Collection<int, User>
  317.      */
  318.     public function getUsers(): Collection
  319.     {
  320.         return $this->users;
  321.     }
  323.     public function addUser(User $user): static
  324.     {
  325.         if (!$this->users->contains($user)) {
  326.             $this->users->add($user);
  327.             $user->setEntreprise($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeUser(User $user): static
  334.     {
  335.         if ($this->users->removeElement($user)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($user->getEntreprise() === $this) {
  338.                 $user->setEntreprise(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     /**
  346.      * @return Collection<int, Role>
  347.      */
  348.     public function getRoles(): Collection
  349.     {
  350.         return $this->roles;
  351.     }
  353.     public function addRole(Role $role): static
  354.     {
  355.         if (!$this->roles->contains($role)) {
  356.             $this->roles->add($role);
  357.             $role->setMarchand($this);
  358.         }
  360.         return $this;
  361.     }
  363.     public function removeRole(Role $role): static
  364.     {
  365.         if ($this->roles->removeElement($role)) {
  366.             // set the owning side to null (unless already changed)
  367.             if ($role->getMarchand() === $this) {
  368.                 $role->setMarchand(null);
  369.             }
  370.         }
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection<int, CategoryResidence>
  377.      */
  378.     public function getCategoryResidences(): Collection
  379.     {
  380.         return $this->categoryResidences;
  381.     }
  383.     public function addCategoryResidence(CategoryResidence $categoryResidence): static
  384.     {
  385.         if (!$this->categoryResidences->contains($categoryResidence)) {
  386.             $this->categoryResidences->add($categoryResidence);
  387.             $categoryResidence->setMarchand($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeCategoryResidence(CategoryResidence $categoryResidence): static
  394.     {
  395.         if ($this->categoryResidences->removeElement($categoryResidence)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($categoryResidence->getMarchand() === $this) {
  398.                 $categoryResidence->setMarchand(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.     /**
  406.      * @return Collection<int, ResidenceImmeuble>
  407.      */
  408.     public function getResidenceImmeubles(): Collection
  409.     {
  410.         return $this->residenceImmeubles;
  411.     }
  413.     public function addResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
  414.     {
  415.         if (!$this->residenceImmeubles->contains($residenceImmeuble)) {
  416.             $this->residenceImmeubles->add($residenceImmeuble);
  417.             $residenceImmeuble->setMarchand($this);
  418.         }
  420.         return $this;
  421.     }
  423.     public function removeResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
  424.     {
  425.         if ($this->residenceImmeubles->removeElement($residenceImmeuble)) {
  426.             // set the owning side to null (unless already changed)
  427.             if ($residenceImmeuble->getMarchand() === $this) {
  428.                 $residenceImmeuble->setMarchand(null);
  429.             }
  430.         }
  432.         return $this;
  433.     }
  435.     /**
  436.      * @return Collection<int, PaymentGenerator>
  437.      */
  438.     public function getPaymentGenerators(): Collection
  439.     {
  440.         return $this->paymentGenerators;
  441.     }
  443.     public function addPaymentGenerator(PaymentGenerator $paymentGenerator): static
  444.     {
  445.         if (!$this->paymentGenerators->contains($paymentGenerator)) {
  446.             $this->paymentGenerators->add($paymentGenerator);
  447.             $paymentGenerator->setMarchand($this);
  448.         }
  450.         return $this;
  451.     }
  453.     public function removePaymentGenerator(PaymentGenerator $paymentGenerator): static
  454.     {
  455.         if ($this->paymentGenerators->removeElement($paymentGenerator)) {
  456.             // set the owning side to null (unless already changed)
  457.             if ($paymentGenerator->getMarchand() === $this) {
  458.                 $paymentGenerator->setMarchand(null);
  459.             }
  460.         }
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, Prestataire>
  467.      */
  468.     public function getPrestataires(): Collection
  469.     {
  470.         return $this->prestataires;
  471.     }
  473.     public function addPrestataire(Prestataire $prestataire): static
  474.     {
  475.         if (!$this->prestataires->contains($prestataire)) {
  476.             $this->prestataires->add($prestataire);
  477.             $prestataire->setMarchand($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removePrestataire(Prestataire $prestataire): static
  484.     {
  485.         if ($this->prestataires->removeElement($prestataire)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($prestataire->getMarchand() === $this) {
  488.                 $prestataire->setMarchand(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     /**
  496.      * @return Collection<int, Incident>
  497.      */
  498.     public function getIncidents(): Collection
  499.     {
  500.         return $this->incidents;
  501.     }
  503.     public function addIncident(Incident $incident): static
  504.     {
  505.         if (!$this->incidents->contains($incident)) {
  506.             $this->incidents->add($incident);
  507.             $incident->setMarchand($this);
  508.         }
  510.         return $this;
  511.     }
  513.     public function removeIncident(Incident $incident): static
  514.     {
  515.         if ($this->incidents->removeElement($incident)) {
  516.             // set the owning side to null (unless already changed)
  517.             if ($incident->getMarchand() === $this) {
  518.                 $incident->setMarchand(null);
  519.             }
  520.         }
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, Template>
  527.      */
  528.     public function getTemplates(): Collection
  529.     {
  530.         return $this->templates;
  531.     }
  533.     public function addTemplate(Template $template): static
  534.     {
  535.         if (!$this->templates->contains($template)) {
  536.             $this->templates->add($template);
  537.             $template->setMarchand($this);
  538.         }
  540.         return $this;
  541.     }
  543.     public function removeTemplate(Template $template): static
  544.     {
  545.         if ($this->templates->removeElement($template)) {
  546.             // set the owning side to null (unless already changed)
  547.             if ($template->getMarchand() === $this) {
  548.                 $template->setMarchand(null);
  549.             }
  550.         }
  552.         return $this;
  553.     }
  555.     public function isSmsservice(): ?bool
  556.     {
  557.         return $this->smsservice;
  558.     }
  560.     public function setSmsservice(?bool $smsservice): static
  561.     {
  562.         $this->smsservice = $smsservice;
  564.         return $this;
  565.     }
  567.     public function isInvoiceservice(): ?bool
  568.     {
  569.         return $this->invoiceservice;
  570.     }
  572.     public function setInvoiceservice(?bool $invoiceservice): static
  573.     {
  574.         $this->invoiceservice = $invoiceservice;
  576.         return $this;
  577.     }
  579.     /**
  580.      * @return Collection<int, PaymentGaranty>
  581.      */
  582.     public function getPaymentGaranties(): Collection
  583.     {
  584.         return $this->paymentGaranties;
  585.     }
  587.     public function addPaymentGaranty(PaymentGaranty $paymentGaranty): static
  588.     {
  589.         if (!$this->paymentGaranties->contains($paymentGaranty)) {
  590.             $this->paymentGaranties->add($paymentGaranty);
  591.             $paymentGaranty->setMarchand($this);
  592.         }
  594.         return $this;
  595.     }
  597.     public function removePaymentGaranty(PaymentGaranty $paymentGaranty): static
  598.     {
  599.         if ($this->paymentGaranties->removeElement($paymentGaranty)) {
  600.             // set the owning side to null (unless already changed)
  601.             if ($paymentGaranty->getMarchand() === $this) {
  602.                 $paymentGaranty->setMarchand(null);
  603.             }
  604.         }
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection<int, IncidentUpdate>
  611.      */
  612.     public function getIncidentUpdates(): Collection
  613.     {
  614.         return $this->incidentUpdates;
  615.     }
  617.     public function addIncidentUpdate(IncidentUpdate $incidentUpdate): static
  618.     {
  619.         if (!$this->incidentUpdates->contains($incidentUpdate)) {
  620.             $this->incidentUpdates->add($incidentUpdate);
  621.             $incidentUpdate->setMarchand($this);
  622.         }
  624.         return $this;
  625.     }
  627.     public function removeIncidentUpdate(IncidentUpdate $incidentUpdate): static
  628.     {
  629.         if ($this->incidentUpdates->removeElement($incidentUpdate)) {
  630.             // set the owning side to null (unless already changed)
  631.             if ($incidentUpdate->getMarchand() === $this) {
  632.                 $incidentUpdate->setMarchand(null);
  633.             }
  634.         }
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection<int, Service>
  641.      */
  642.     public function getServices(): Collection
  643.     {
  644.         return $this->services;
  645.     }
  647.     public function addService(Service $service): static
  648.     {
  649.         if (!$this->services->contains($service)) {
  650.             $this->services->add($service);
  651.             $service->setMarchand($this);
  652.         }
  654.         return $this;
  655.     }
  657.     public function removeService(Service $service): static
  658.     {
  659.         if ($this->services->removeElement($service)) {
  660.             // set the owning side to null (unless already changed)
  661.             if ($service->getMarchand() === $this) {
  662.                 $service->setMarchand(null);
  663.             }
  664.         }
  666.         return $this;
  667.     }
  669.     public function getAdmin(): ?Admin
  670.     {
  671.         return $this->admin;
  672.     }
  674.     public function setAdmin(?Admin $admin): static
  675.     {
  676.         $this->admin = $admin;
  678.         return $this;
  679.     }
  681.     public function getIdnat(): ?string
  682.     {
  683.         return $this->idnat;
  684.     }
  686.     public function setIdnat(?string $idnat): static
  687.     {
  688.         $this->idnat = $idnat;
  690.         return $this;
  691.     }
  693.     public function getNumeroimpot(): ?string
  694.     {
  695.         return $this->numeroimpot;
  696.     }
  698.     public function setNumeroimpot(?string $numeroimpot): static
  699.     {
  700.         $this->numeroimpot = $numeroimpot;
  702.         return $this;
  703.     }
  705.     public function getCountry(): ?Country
  706.     {
  707.         return $this->country;
  708.     }
  710.     public function setCountry(?Country $country): static
  711.     {
  712.         $this->country = $country;
  714.         return $this;
  715.     }
  717.     public function getCity(): ?string
  718.     {
  719.         return $this->city;
  720.     }
  722.     public function setCity(?string $city): static
  723.     {
  724.         $this->city = $city;
  726.         return $this;
  727.     }
  729.     public function getProvince(): ?string
  730.     {
  731.         return $this->province;
  732.     }
  734.     public function setProvince(?string $province): static
  735.     {
  736.         $this->province = $province;
  738.         return $this;
  739.     }
  741.     public function getNbrebiensimmobiliers(): ?int
  742.     {
  743.         return $this->nbrebiensimmobiliers;
  744.     }
  746.     public function setNbrebiensimmobiliers(?int $nbrebiensimmobiliers): static
  747.     {
  748.         $this->nbrebiensimmobiliers = $nbrebiensimmobiliers;
  750.         return $this;
  751.     }
  753.     /**
  754.      * @return Collection<int, Subscription>
  755.      */
  756.     public function getSubscriptions(): Collection
  757.     {
  758.         return $this->subscriptions;
  759.     }
  761.     public function addSubscription(Subscription $subscription): static
  762.     {
  763.         if (!$this->subscriptions->contains($subscription)) {
  764.             $this->subscriptions->add($subscription);
  765.             $subscription->setEntreprise($this);
  766.         }
  768.         return $this;
  769.     }
  771.     public function removeEntreprisePackage(Subscription $subscription): static
  772.     {
  773.         if ($this->subscriptions->removeElement($subscription)) {
  774.             // set the owning side to null (unless already changed)
  775.             if ($subscription->getEntreprise() === $this) {
  776.                 $subscription->setEntreprise(null);
  777.             }
  778.         }
  780.         return $this;
  781.     }
  783.     public function isFreeTrail(): ?bool
  784.     {
  785.         return $this->freeTrail;
  786.     }
  788.     public function setFreeTrail(?bool $freeTrail): static
  789.     {
  790.         $this->freeTrail = $freeTrail;
  792.         return $this;
  793.     }
  795.     public function getPackage(): ?Package
  796.     {
  797.         return $this->package;
  798.     }
  800.     public function setPackage(?Package $package): static
  801.     {
  802.         $this->package = $package;
  804.         return $this;
  805.     }
  807.     public function getPeriod(): ?string
  808.     {
  809.         return $this->period;
  810.     }
  812.     public function setPeriod(?string $period): static
  813.     {
  814.         $this->period = $period;
  816.         return $this;
  817.     }
  819.     public function isRecallpaymentnotification(): ?bool
  820.     {
  821.         return $this->recallpaymentnotification;
  822.     }
  824.     public function setRecallpaymentnotification(bool $recallpaymentnotification): static
  825.     {
  826.         $this->recallpaymentnotification = $recallpaymentnotification;
  828.         return $this;
  829.     }
  830.     public function getSmartPaykey(): ?string
  831.     {
  832.         return $this->smartPaykey;
  833.     }
  835.     public function setSmartPaykey(?string $smartPaykey): void
  836.     {
  837.         $this->smartPaykey = $smartPaykey;
  838.     }
  840.     /**
  841.      * @return Collection<int, Announcement>
  842.      */
  843.     public function getAnnouncements(): Collection
  844.     {
  845.         return $this->announcements;
  846.     }
  848.     public function addAnnouncement(Announcement $announcement): static
  849.     {
  850.         if (!$this->announcements->contains($announcement)) {
  851.             $this->announcements->add($announcement);
  852.             $announcement->setEntreprise($this);
  853.         }
  855.         return $this;
  856.     }
  858.     public function removeAnnouncement(Announcement $announcement): static
  859.     {
  860.         if ($this->announcements->removeElement($announcement)) {
  861.             // set the owning side to null (unless already changed)
  862.             if ($announcement->getEntreprise() === $this) {
  863.                 $announcement->setEntreprise(null);
  864.             }
  865.         }
  867.         return $this;
  868.     }
  870.     /**
  871.      * @return Collection<int, CashJournal>
  872.      */
  873.     public function getCashJournals(): Collection
  874.     {
  875.         return $this->cashJournals;
  876.     }
  878.     public function addCashJournal(CashJournal $cashJournal): static
  879.     {
  880.         if (!$this->cashJournals->contains($cashJournal)) {
  881.             $this->cashJournals->add($cashJournal);
  882.             $cashJournal->setMarchand($this);
  883.         }
  885.         return $this;
  886.     }
  888.     public function removeCashJournal(CashJournal $cashJournal): static
  889.     {
  890.         if ($this->cashJournals->removeElement($cashJournal)) {
  891.             // set the owning side to null (unless already changed)
  892.             if ($cashJournal->getMarchand() === $this) {
  893.                 $cashJournal->setMarchand(null);
  894.             }
  895.         }
  897.         return $this;
  898.     }
  900.     /**
  901.      * @return Collection<int, CashJournalEntry>
  902.      */
  903.     public function getCashJournalEntries(): Collection
  904.     {
  905.         return $this->cashJournalEntries;
  906.     }
  908.     public function addCashJournalEntry(CashJournalEntry $cashJournalEntry): static
  909.     {
  910.         if (!$this->cashJournalEntries->contains($cashJournalEntry)) {
  911.             $this->cashJournalEntries->add($cashJournalEntry);
  912.             $cashJournalEntry->setMarchand($this);
  913.         }
  915.         return $this;
  916.     }
  918.     public function removeCashJournalEntry(CashJournalEntry $cashJournalEntry): static
  919.     {
  920.         if ($this->cashJournalEntries->removeElement($cashJournalEntry)) {
  921.             // set the owning side to null (unless already changed)
  922.             if ($cashJournalEntry->getMarchand() === $this) {
  923.                 $cashJournalEntry->setMarchand(null);
  924.             }
  925.         }
  927.         return $this;
  928.     }
  930.     /**
  931.      * @return Collection<int, Charge>
  932.      */
  933.     public function getCharges(): Collection
  934.     {
  935.         return $this->charges;
  936.     }
  938.     public function addCharge(Charge $charge): static
  939.     {
  940.         if (!$this->charges->contains($charge)) {
  941.             $this->charges->add($charge);
  942.             $charge->setMarchand($this);
  943.         }
  945.         return $this;
  946.     }
  948.     public function removeCharge(Charge $charge): static
  949.     {
  950.         if ($this->charges->removeElement($charge)) {
  951.             // set the owning side to null (unless already changed)
  952.             if ($charge->getMarchand() === $this) {
  953.                 $charge->setMarchand(null);
  954.             }
  955.         }
  957.         return $this;
  958.     }
  960.     /**
  961.      * @return Collection<int, ChargeAllocation>
  962.      */
  963.     public function getChargeAllocations(): Collection
  964.     {
  965.         return $this->chargeAllocations;
  966.     }
  968.     public function addChargeAllocation(ChargeAllocation $chargeAllocation): static
  969.     {
  970.         if (!$this->chargeAllocations->contains($chargeAllocation)) {
  971.             $this->chargeAllocations->add($chargeAllocation);
  972.             $chargeAllocation->setMarchand($this);
  973.         }
  975.         return $this;
  976.     }
  978.     public function removeChargeAllocation(ChargeAllocation $chargeAllocation): static
  979.     {
  980.         if ($this->chargeAllocations->removeElement($chargeAllocation)) {
  981.             // set the owning side to null (unless already changed)
  982.             if ($chargeAllocation->getMarchand() === $this) {
  983.                 $chargeAllocation->setMarchand(null);
  984.             }
  985.         }
  987.         return $this;
  988.     }
  990.     public function isMakeJournal(): ?bool
  991.     {
  992.         return $this->makeJournal;
  993.     }
  995.     public function setMakeJournal(?bool $makeJournal): static
  996.     {
  997.         $this->makeJournal = $makeJournal;
  999.         return $this;
  1000.     }
  1002.     /**
  1003.      * @return Collection<int, Log>
  1004.      */
  1005.     public function getLogs(): Collection
  1006.     {
  1007.         return $this->logs;
  1008.     }
  1010.     public function addLog(Log $log): static
  1011.     {
  1012.         if (!$this->logs->contains($log)) {
  1013.             $this->logs->add($log);
  1014.             $log->setMarchand($this);
  1015.         }
  1017.         return $this;
  1018.     }
  1020.     public function removeLog(Log $log): static
  1021.     {
  1022.         if ($this->logs->removeElement($log)) {
  1023.             // set the owning side to null (unless already changed)
  1024.             if ($log->getMarchand() === $this) {
  1025.                 $log->setMarchand(null);
  1026.             }
  1027.         }
  1029.         return $this;
  1030.     }
  1032.     /**
  1033.      * @return Collection<int, Reservation>
  1034.      */
  1035.     public function getReservations(): Collection
  1036.     {
  1037.         return $this->reservations;
  1038.     }
  1040.     public function addReservation(Reservation $reservation): static
  1041.     {
  1042.         if (!$this->reservations->contains($reservation)) {
  1043.             $this->reservations->add($reservation);
  1044.             $reservation->setMarchand($this);
  1045.         }
  1047.         return $this;
  1048.     }
  1050.     public function removeReservation(Reservation $reservation): static
  1051.     {
  1052.         if ($this->reservations->removeElement($reservation)) {
  1053.             // set the owning side to null (unless already changed)
  1054.             if ($reservation->getMarchand() === $this) {
  1055.                 $reservation->setMarchand(null);
  1056.             }
  1057.         }
  1059.         return $this;
  1060.     }
  1062.     /**
  1063.      * @return Collection<int, UserEntreprise>
  1064.      */
  1065.     public function getUserEntreprises(): Collection
  1066.     {
  1067.         return $this->userEntreprises;
  1068.     }
  1070.     public function addUserEntreprise(UserEntreprise $userEntreprise): static
  1071.     {
  1072.         if (!$this->userEntreprises->contains($userEntreprise)) {
  1073.             $this->userEntreprises->add($userEntreprise);
  1074.             $userEntreprise->setEntreprise($this);
  1075.         }
  1077.         return $this;
  1078.     }
  1080.     public function removeUserEntreprise(UserEntreprise $userEntreprise): static
  1081.     {
  1082.         if ($this->userEntreprises->removeElement($userEntreprise)) {
  1083.             // set the owning side to null (unless already changed)
  1084.             if ($userEntreprise->getEntreprise() === $this) {
  1085.                 $userEntreprise->setEntreprise(null);
  1086.             }
  1087.         }
  1089.         return $this;
  1090.     }
  1092.     public function getOwner(): ?User
  1093.     {
  1094.         return $this->owner;
  1095.     }
  1097.     public function setOwner(?User $owner): static
  1098.     {
  1099.         $this->owner = $owner;
  1101.         return $this;
  1102.     }
  1104. }