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\DBAL\Types\Types;
10. use Doctrine\ORM\Mapping as ORM;
12. #[ORM\Entity(repositoryClass: EntrepriseRepository::class)]
13. #[ORM\HasLifecycleCallbacks]
14. class Entreprise
15. {
16.     use TimeStampTrait;
18.     #[ORM\Id]
19.     #[ORM\GeneratedValue]
20.     #[ORM\Column]
21.     private ?int $id = null;
23.     #[ORM\Column(length: 100)]
24.     private ?string $code = null;
26.     #[ORM\Column(length: 100)]
27.     private ?string $name = null;
29.     #[ORM\Column(length: 255, nullable: true)]
30.     private ?string $adress = null;
32.     #[ORM\Column(length: 100, nullable: true)]
33.     private ?string $email = null;
35.     #[ORM\Column(length: 50, nullable: true)]
36.     private ?string $phone = null;
38.     #[ORM\Column(length: 100, nullable: true)]
39.     private ?string $pseudo = null;
41.     #[ORM\Column(length: 255, nullable: true)]
42.     private ?string $description = null;
44.     #[ORM\Column(length: 50, nullable: true)]
45.     private ?string $rccm = null;
47.     #[ORM\Column(length: 100, nullable: true)]
48.     private ?string $icon = null;
50.     #[ORM\Column(nullable: true)]
51.     private ?bool $status = null;
53.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: User::class)]
54.     private Collection $users;
56.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Role::class)]
57.     private Collection $roles;
59.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CategoryResidence::class)]
60.     private Collection $categoryResidences;
62.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: ResidenceImmeuble::class)]
63.     private Collection $residenceImmeubles;
65.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: PaymentGenerator::class)]
66.     private Collection $paymentGenerators;
68.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Prestataire::class)]
69.     private Collection $prestataires;
71.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Incident::class)]
72.     private Collection $incidents;
74.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Template::class)]
75.     private Collection $templates;
77.     #[ORM\Column(nullable: true)]
78.     private ?bool $smsservice = null;
80.     #[ORM\Column(nullable: true)]
81.     private ?bool $invoiceservice = null;
83.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: PaymentGaranty::class)]
84.     private Collection $paymentGaranties;
86.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: IncidentUpdate::class)]
87.     private Collection $incidentUpdates;
89.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Service::class)]
90.     private Collection $services;
92.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
93.     private ?Admin $admin = null;
95.     #[ORM\Column(length: 50, nullable: true)]
96.     private ?string $idnat = null;
98.     #[ORM\Column(length: 50, nullable: true)]
99.     private ?string $numeroimpot = null;
101.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
102.     private ?Country $country = null;
104.     #[ORM\Column(length: 50, nullable: true)]
105.     private ?string $city = null;
107.     #[ORM\Column(length: 50, nullable: true)]
108.     private ?string $province = null;
110.     #[ORM\Column(nullable: true)]
111.     private ?int $nbrebiensimmobiliers = null;
113.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Subscription::class)]
114.     private Collection $subscriptions;
116.     #[ORM\Column(nullable: true)]
117.     private ?bool $freeTrail = null;
119.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
120.     private ?Package $package = null;
122.     #[ORM\Column(length: 25, nullable: true)]
123.     private ?string $period = null;
125.     #[ORM\Column]
126.     private ?bool $recallpaymentnotification = null;
128.     #[ORM\Column(length: 255, nullable: true)]
129.     private ?string $smartPaykey = null;
131.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Announcement::class)]
132.     private Collection $announcements;
134.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CashJournal::class)]
135.     private Collection $cashJournals;
137.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: CashJournalEntry::class)]
138.     private Collection $cashJournalEntries;
140.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Charge::class)]
141.     private Collection $charges;
143.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: ChargeAllocation::class)]
144.     private Collection $chargeAllocations;
146.     #[ORM\Column(nullable: true)]
147.     private ?bool $makeJournal = null;
149.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Log::class)]
150.     private Collection $logs;
152.     #[ORM\OneToMany(mappedBy: 'marchand', targetEntity: Reservation::class)]
153.     private Collection $reservations;
155.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: UserEntreprise::class)]
156.     private Collection $userEntreprises;
158.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
159.     private ?User $owner = null;
161.     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
162.     private ?string $defaultFxRate = null;
164.     #[ORM\ManyToOne(inversedBy: 'entreprises')]
165.     private ?Currency $currency = null;
167.     #[ORM\Column(nullable: true)]
168.     private ?bool $isDefaultFxRateApply = null;
170.     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
171.     private ?string $tva = null;
173.     #[ORM\Column(length: 20, nullable: true)]
174.     private ?string $dgiNif = null;
176.     #[ORM\Column(length: 64, nullable: true)]
177.     private ?string $dgiIsf = null;
179.     #[ORM\Column(type: Types::TEXT, nullable: true)]
180.     private ?string $dgiToken = null;
182.     #[ORM\Column(length: 10, nullable: true)]
183.     private ?string $dgiEnv = null;
185.     #[ORM\Column(length: 1, nullable: true)]
186.     private ?string $dgiDefaultTaxGroup = null;
188.     #[ORM\Column(length: 50, nullable: true)]
189.     private ?string $dgiDefaultItemType = null;
191.     #[ORM\Column(nullable: true)]
192.     private ?bool $dgiServiceEnabled = null;
194.     #[ORM\Column(type: Types::DECIMAL, precision: 5, scale: 2, nullable: true)]
195.     private ?string $dgiTaxRate = null;
197.     public function __construct()
198.     {
199.         $this->users = new ArrayCollection();
200.         $this->roles = new ArrayCollection();
201.         $this->categoryResidences = new ArrayCollection();
202.         $this->residenceImmeubles = new ArrayCollection();
203.         $this->paymentGenerators = new ArrayCollection();
204.         $this->prestataires = new ArrayCollection();
205.         $this->incidents = new ArrayCollection();
206.         $this->templates = new ArrayCollection();
207.         $this->paymentGaranties = new ArrayCollection();
208.         $this->incidentUpdates = new ArrayCollection();
209.         $this->services = new ArrayCollection();
210.         $this->subscriptions = new ArrayCollection();
211.         $this->announcements = new ArrayCollection();
212.         $this->cashJournals = new ArrayCollection();
213.         $this->cashJournalEntries = new ArrayCollection();
214.         $this->charges = new ArrayCollection();
215.         $this->chargeAllocations = new ArrayCollection();
216.         $this->logs = new ArrayCollection();
217.         $this->reservations = new ArrayCollection();
218.         $this->userEntreprises = new ArrayCollection();
219.     }
221.     public function getId(): ?int
222.     {
223.         return $this->id;
224.     }
226.     public function getCode(): ?string
227.     {
228.         return $this->code;
229.     }
231.     public function setCode(string $code): static
232.     {
233.         $this->code = $code;
235.         return $this;
236.     }
238.     public function getName(): ?string
239.     {
240.         return $this->name;
241.     }
243.     public function setName(string $name): static
244.     {
245.         $this->name = $name;
247.         return $this;
248.     }
250.     public function getAdress(): ?string
251.     {
252.         return $this->adress;
253.     }
255.     public function setAdress(?string $adress): static
256.     {
257.         $this->adress = $adress;
259.         return $this;
260.     }
262.     public function getEmail(): ?string
263.     {
264.         return $this->email;
265.     }
267.     public function setEmail(?string $email): static
268.     {
269.         $this->email = $email;
271.         return $this;
272.     }
274.     public function getPhone(): ?string
275.     {
276.         return $this->phone;
277.     }
279.     public function setPhone(?string $phone): static
280.     {
281.         $this->phone = $phone;
283.         return $this;
284.     }
286.     public function getPseudo(): ?string
287.     {
288.         return $this->pseudo;
289.     }
291.     public function setPseudo(?string $pseudo): static
292.     {
293.         $this->pseudo = $pseudo;
295.         return $this;
296.     }
298.     public function getDescription(): ?string
299.     {
300.         return $this->description;
301.     }
303.     public function setDescription(?string $description): static
304.     {
305.         $this->description = $description;
307.         return $this;
308.     }
310.     public function getRccm(): ?string
311.     {
312.         return $this->rccm;
313.     }
315.     public function setRccm(?string $rccm): static
316.     {
317.         $this->rccm = $rccm;
319.         return $this;
320.     }
322.     public function getIcon(): ?string
323.     {
324.         return $this->icon;
325.     }
327.     public function setIcon(?string $icon): static
328.     {
329.         $this->icon = $icon;
331.         return $this;
332.     }
334.     public function isStatus(): ?bool
335.     {
336.         return $this->status;
337.     }
339.     public function setStatus(?bool $status): static
340.     {
341.         $this->status = $status;
343.         return $this;
344.     }
347.     public function __toString(): string
348.     {
349.         return $this->name;
350.     }
352.     /**
353.      * @return Collection<int, User>
354.      */
355.     public function getUsers(): Collection
356.     {
357.         return $this->users;
358.     }
360.     public function addUser(User $user): static
361.     {
362.         if (!$this->users->contains($user)) {
363.             $this->users->add($user);
364.             $user->setEntreprise($this);
365.         }
367.         return $this;
368.     }
370.     public function removeUser(User $user): static
371.     {
372.         if ($this->users->removeElement($user)) {
373.             // set the owning side to null (unless already changed)
374.             if ($user->getEntreprise() === $this) {
375.                 $user->setEntreprise(null);
376.             }
377.         }
379.         return $this;
380.     }
382.     /**
383.      * @return Collection<int, Role>
384.      */
385.     public function getRoles(): Collection
386.     {
387.         return $this->roles;
388.     }
390.     public function addRole(Role $role): static
391.     {
392.         if (!$this->roles->contains($role)) {
393.             $this->roles->add($role);
394.             $role->setMarchand($this);
395.         }
397.         return $this;
398.     }
400.     public function removeRole(Role $role): static
401.     {
402.         if ($this->roles->removeElement($role)) {
403.             // set the owning side to null (unless already changed)
404.             if ($role->getMarchand() === $this) {
405.                 $role->setMarchand(null);
406.             }
407.         }
409.         return $this;
410.     }
412.     /**
413.      * @return Collection<int, CategoryResidence>
414.      */
415.     public function getCategoryResidences(): Collection
416.     {
417.         return $this->categoryResidences;
418.     }
420.     public function addCategoryResidence(CategoryResidence $categoryResidence): static
421.     {
422.         if (!$this->categoryResidences->contains($categoryResidence)) {
423.             $this->categoryResidences->add($categoryResidence);
424.             $categoryResidence->setMarchand($this);
425.         }
427.         return $this;
428.     }
430.     public function removeCategoryResidence(CategoryResidence $categoryResidence): static
431.     {
432.         if ($this->categoryResidences->removeElement($categoryResidence)) {
433.             // set the owning side to null (unless already changed)
434.             if ($categoryResidence->getMarchand() === $this) {
435.                 $categoryResidence->setMarchand(null);
436.             }
437.         }
439.         return $this;
440.     }
442.     /**
443.      * @return Collection<int, ResidenceImmeuble>
444.      */
445.     public function getResidenceImmeubles(): Collection
446.     {
447.         return $this->residenceImmeubles;
448.     }
450.     public function addResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
451.     {
452.         if (!$this->residenceImmeubles->contains($residenceImmeuble)) {
453.             $this->residenceImmeubles->add($residenceImmeuble);
454.             $residenceImmeuble->setMarchand($this);
455.         }
457.         return $this;
458.     }
460.     public function removeResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
461.     {
462.         if ($this->residenceImmeubles->removeElement($residenceImmeuble)) {
463.             // set the owning side to null (unless already changed)
464.             if ($residenceImmeuble->getMarchand() === $this) {
465.                 $residenceImmeuble->setMarchand(null);
466.             }
467.         }
469.         return $this;
470.     }
472.     /**
473.      * @return Collection<int, PaymentGenerator>
474.      */
475.     public function getPaymentGenerators(): Collection
476.     {
477.         return $this->paymentGenerators;
478.     }
480.     public function addPaymentGenerator(PaymentGenerator $paymentGenerator): static
481.     {
482.         if (!$this->paymentGenerators->contains($paymentGenerator)) {
483.             $this->paymentGenerators->add($paymentGenerator);
484.             $paymentGenerator->setMarchand($this);
485.         }
487.         return $this;
488.     }
490.     public function removePaymentGenerator(PaymentGenerator $paymentGenerator): static
491.     {
492.         if ($this->paymentGenerators->removeElement($paymentGenerator)) {
493.             // set the owning side to null (unless already changed)
494.             if ($paymentGenerator->getMarchand() === $this) {
495.                 $paymentGenerator->setMarchand(null);
496.             }
497.         }
499.         return $this;
500.     }
502.     /**
503.      * @return Collection<int, Prestataire>
504.      */
505.     public function getPrestataires(): Collection
506.     {
507.         return $this->prestataires;
508.     }
510.     public function addPrestataire(Prestataire $prestataire): static
511.     {
512.         if (!$this->prestataires->contains($prestataire)) {
513.             $this->prestataires->add($prestataire);
514.             $prestataire->setMarchand($this);
515.         }
517.         return $this;
518.     }
520.     public function removePrestataire(Prestataire $prestataire): static
521.     {
522.         if ($this->prestataires->removeElement($prestataire)) {
523.             // set the owning side to null (unless already changed)
524.             if ($prestataire->getMarchand() === $this) {
525.                 $prestataire->setMarchand(null);
526.             }
527.         }
529.         return $this;
530.     }
532.     /**
533.      * @return Collection<int, Incident>
534.      */
535.     public function getIncidents(): Collection
536.     {
537.         return $this->incidents;
538.     }
540.     public function addIncident(Incident $incident): static
541.     {
542.         if (!$this->incidents->contains($incident)) {
543.             $this->incidents->add($incident);
544.             $incident->setMarchand($this);
545.         }
547.         return $this;
548.     }
550.     public function removeIncident(Incident $incident): static
551.     {
552.         if ($this->incidents->removeElement($incident)) {
553.             // set the owning side to null (unless already changed)
554.             if ($incident->getMarchand() === $this) {
555.                 $incident->setMarchand(null);
556.             }
557.         }
559.         return $this;
560.     }
562.     /**
563.      * @return Collection<int, Template>
564.      */
565.     public function getTemplates(): Collection
566.     {
567.         return $this->templates;
568.     }
570.     public function addTemplate(Template $template): static
571.     {
572.         if (!$this->templates->contains($template)) {
573.             $this->templates->add($template);
574.             $template->setMarchand($this);
575.         }
577.         return $this;
578.     }
580.     public function removeTemplate(Template $template): static
581.     {
582.         if ($this->templates->removeElement($template)) {
583.             // set the owning side to null (unless already changed)
584.             if ($template->getMarchand() === $this) {
585.                 $template->setMarchand(null);
586.             }
587.         }
589.         return $this;
590.     }
592.     public function isSmsservice(): ?bool
593.     {
594.         return $this->smsservice;
595.     }
597.     public function setSmsservice(?bool $smsservice): static
598.     {
599.         $this->smsservice = $smsservice;
601.         return $this;
602.     }
604.     public function isInvoiceservice(): ?bool
605.     {
606.         return $this->invoiceservice;
607.     }
609.     public function setInvoiceservice(?bool $invoiceservice): static
610.     {
611.         $this->invoiceservice = $invoiceservice;
613.         return $this;
614.     }
616.     /**
617.      * @return Collection<int, PaymentGaranty>
618.      */
619.     public function getPaymentGaranties(): Collection
620.     {
621.         return $this->paymentGaranties;
622.     }
624.     public function addPaymentGaranty(PaymentGaranty $paymentGaranty): static
625.     {
626.         if (!$this->paymentGaranties->contains($paymentGaranty)) {
627.             $this->paymentGaranties->add($paymentGaranty);
628.             $paymentGaranty->setMarchand($this);
629.         }
631.         return $this;
632.     }
634.     public function removePaymentGaranty(PaymentGaranty $paymentGaranty): static
635.     {
636.         if ($this->paymentGaranties->removeElement($paymentGaranty)) {
637.             // set the owning side to null (unless already changed)
638.             if ($paymentGaranty->getMarchand() === $this) {
639.                 $paymentGaranty->setMarchand(null);
640.             }
641.         }
643.         return $this;
644.     }
646.     /**
647.      * @return Collection<int, IncidentUpdate>
648.      */
649.     public function getIncidentUpdates(): Collection
650.     {
651.         return $this->incidentUpdates;
652.     }
654.     public function addIncidentUpdate(IncidentUpdate $incidentUpdate): static
655.     {
656.         if (!$this->incidentUpdates->contains($incidentUpdate)) {
657.             $this->incidentUpdates->add($incidentUpdate);
658.             $incidentUpdate->setMarchand($this);
659.         }
661.         return $this;
662.     }
664.     public function removeIncidentUpdate(IncidentUpdate $incidentUpdate): static
665.     {
666.         if ($this->incidentUpdates->removeElement($incidentUpdate)) {
667.             // set the owning side to null (unless already changed)
668.             if ($incidentUpdate->getMarchand() === $this) {
669.                 $incidentUpdate->setMarchand(null);
670.             }
671.         }
673.         return $this;
674.     }
676.     /**
677.      * @return Collection<int, Service>
678.      */
679.     public function getServices(): Collection
680.     {
681.         return $this->services;
682.     }
684.     public function addService(Service $service): static
685.     {
686.         if (!$this->services->contains($service)) {
687.             $this->services->add($service);
688.             $service->setMarchand($this);
689.         }
691.         return $this;
692.     }
694.     public function removeService(Service $service): static
695.     {
696.         if ($this->services->removeElement($service)) {
697.             // set the owning side to null (unless already changed)
698.             if ($service->getMarchand() === $this) {
699.                 $service->setMarchand(null);
700.             }
701.         }
703.         return $this;
704.     }
706.     public function getAdmin(): ?Admin
707.     {
708.         return $this->admin;
709.     }
711.     public function setAdmin(?Admin $admin): static
712.     {
713.         $this->admin = $admin;
715.         return $this;
716.     }
718.     public function getIdnat(): ?string
719.     {
720.         return $this->idnat;
721.     }
723.     public function setIdnat(?string $idnat): static
724.     {
725.         $this->idnat = $idnat;
727.         return $this;
728.     }
730.     public function getNumeroimpot(): ?string
731.     {
732.         return $this->numeroimpot;
733.     }
735.     public function setNumeroimpot(?string $numeroimpot): static
736.     {
737.         $this->numeroimpot = $numeroimpot;
739.         return $this;
740.     }
742.     public function getCountry(): ?Country
743.     {
744.         return $this->country;
745.     }
747.     public function setCountry(?Country $country): static
748.     {
749.         $this->country = $country;
751.         return $this;
752.     }
754.     public function getCity(): ?string
755.     {
756.         return $this->city;
757.     }
759.     public function setCity(?string $city): static
760.     {
761.         $this->city = $city;
763.         return $this;
764.     }
766.     public function getProvince(): ?string
767.     {
768.         return $this->province;
769.     }
771.     public function setProvince(?string $province): static
772.     {
773.         $this->province = $province;
775.         return $this;
776.     }
778.     public function getNbrebiensimmobiliers(): ?int
779.     {
780.         return $this->nbrebiensimmobiliers;
781.     }
783.     public function setNbrebiensimmobiliers(?int $nbrebiensimmobiliers): static
784.     {
785.         $this->nbrebiensimmobiliers = $nbrebiensimmobiliers;
787.         return $this;
788.     }
790.     /**
791.      * @return Collection<int, Subscription>
792.      */
793.     public function getSubscriptions(): Collection
794.     {
795.         return $this->subscriptions;
796.     }
798.     public function addSubscription(Subscription $subscription): static
799.     {
800.         if (!$this->subscriptions->contains($subscription)) {
801.             $this->subscriptions->add($subscription);
802.             $subscription->setEntreprise($this);
803.         }
805.         return $this;
806.     }
808.     public function removeEntreprisePackage(Subscription $subscription): static
809.     {
810.         if ($this->subscriptions->removeElement($subscription)) {
811.             // set the owning side to null (unless already changed)
812.             if ($subscription->getEntreprise() === $this) {
813.                 $subscription->setEntreprise(null);
814.             }
815.         }
817.         return $this;
818.     }
820.     public function isFreeTrail(): ?bool
821.     {
822.         return $this->freeTrail;
823.     }
825.     public function setFreeTrail(?bool $freeTrail): static
826.     {
827.         $this->freeTrail = $freeTrail;
829.         return $this;
830.     }
832.     public function getPackage(): ?Package
833.     {
834.         return $this->package;
835.     }
837.     public function setPackage(?Package $package): static
838.     {
839.         $this->package = $package;
841.         return $this;
842.     }
844.     public function getPeriod(): ?string
845.     {
846.         return $this->period;
847.     }
849.     public function setPeriod(?string $period): static
850.     {
851.         $this->period = $period;
853.         return $this;
854.     }
856.     public function isRecallpaymentnotification(): ?bool
857.     {
858.         return $this->recallpaymentnotification;
859.     }
861.     public function setRecallpaymentnotification(bool $recallpaymentnotification): static
862.     {
863.         $this->recallpaymentnotification = $recallpaymentnotification;
865.         return $this;
866.     }
867.     public function getSmartPaykey(): ?string
868.     {
869.         return $this->smartPaykey;
870.     }
872.     public function setSmartPaykey(?string $smartPaykey): void
873.     {
874.         $this->smartPaykey = $smartPaykey;
875.     }
877.     /**
878.      * @return Collection<int, Announcement>
879.      */
880.     public function getAnnouncements(): Collection
881.     {
882.         return $this->announcements;
883.     }
885.     public function addAnnouncement(Announcement $announcement): static
886.     {
887.         if (!$this->announcements->contains($announcement)) {
888.             $this->announcements->add($announcement);
889.             $announcement->setEntreprise($this);
890.         }
892.         return $this;
893.     }
895.     public function removeAnnouncement(Announcement $announcement): static
896.     {
897.         if ($this->announcements->removeElement($announcement)) {
898.             // set the owning side to null (unless already changed)
899.             if ($announcement->getEntreprise() === $this) {
900.                 $announcement->setEntreprise(null);
901.             }
902.         }
904.         return $this;
905.     }
907.     /**
908.      * @return Collection<int, CashJournal>
909.      */
910.     public function getCashJournals(): Collection
911.     {
912.         return $this->cashJournals;
913.     }
915.     public function addCashJournal(CashJournal $cashJournal): static
916.     {
917.         if (!$this->cashJournals->contains($cashJournal)) {
918.             $this->cashJournals->add($cashJournal);
919.             $cashJournal->setMarchand($this);
920.         }
922.         return $this;
923.     }
925.     public function removeCashJournal(CashJournal $cashJournal): static
926.     {
927.         if ($this->cashJournals->removeElement($cashJournal)) {
928.             // set the owning side to null (unless already changed)
929.             if ($cashJournal->getMarchand() === $this) {
930.                 $cashJournal->setMarchand(null);
931.             }
932.         }
934.         return $this;
935.     }
937.     /**
938.      * @return Collection<int, CashJournalEntry>
939.      */
940.     public function getCashJournalEntries(): Collection
941.     {
942.         return $this->cashJournalEntries;
943.     }
945.     public function addCashJournalEntry(CashJournalEntry $cashJournalEntry): static
946.     {
947.         if (!$this->cashJournalEntries->contains($cashJournalEntry)) {
948.             $this->cashJournalEntries->add($cashJournalEntry);
949.             $cashJournalEntry->setMarchand($this);
950.         }
952.         return $this;
953.     }
955.     public function removeCashJournalEntry(CashJournalEntry $cashJournalEntry): static
956.     {
957.         if ($this->cashJournalEntries->removeElement($cashJournalEntry)) {
958.             // set the owning side to null (unless already changed)
959.             if ($cashJournalEntry->getMarchand() === $this) {
960.                 $cashJournalEntry->setMarchand(null);
961.             }
962.         }
964.         return $this;
965.     }
967.     /**
968.      * @return Collection<int, Charge>
969.      */
970.     public function getCharges(): Collection
971.     {
972.         return $this->charges;
973.     }
975.     public function addCharge(Charge $charge): static
976.     {
977.         if (!$this->charges->contains($charge)) {
978.             $this->charges->add($charge);
979.             $charge->setMarchand($this);
980.         }
982.         return $this;
983.     }
985.     public function removeCharge(Charge $charge): static
986.     {
987.         if ($this->charges->removeElement($charge)) {
988.             // set the owning side to null (unless already changed)
989.             if ($charge->getMarchand() === $this) {
990.                 $charge->setMarchand(null);
991.             }
992.         }
994.         return $this;
995.     }
997.     /**
998.      * @return Collection<int, ChargeAllocation>
999.      */
1000.     public function getChargeAllocations(): Collection
1001.     {
1002.         return $this->chargeAllocations;
1003.     }
1005.     public function addChargeAllocation(ChargeAllocation $chargeAllocation): static
1006.     {
1007.         if (!$this->chargeAllocations->contains($chargeAllocation)) {
1008.             $this->chargeAllocations->add($chargeAllocation);
1009.             $chargeAllocation->setMarchand($this);
1010.         }
1012.         return $this;
1013.     }
1015.     public function removeChargeAllocation(ChargeAllocation $chargeAllocation): static
1016.     {
1017.         if ($this->chargeAllocations->removeElement($chargeAllocation)) {
1018.             // set the owning side to null (unless already changed)
1019.             if ($chargeAllocation->getMarchand() === $this) {
1020.                 $chargeAllocation->setMarchand(null);
1021.             }
1022.         }
1024.         return $this;
1025.     }
1027.     public function isMakeJournal(): ?bool
1028.     {
1029.         return $this->makeJournal;
1030.     }
1032.     public function setMakeJournal(?bool $makeJournal): static
1033.     {
1034.         $this->makeJournal = $makeJournal;
1036.         return $this;
1037.     }
1039.     /**
1040.      * @return Collection<int, Log>
1041.      */
1042.     public function getLogs(): Collection
1043.     {
1044.         return $this->logs;
1045.     }
1047.     public function addLog(Log $log): static
1048.     {
1049.         if (!$this->logs->contains($log)) {
1050.             $this->logs->add($log);
1051.             $log->setMarchand($this);
1052.         }
1054.         return $this;
1055.     }
1057.     public function removeLog(Log $log): static
1058.     {
1059.         if ($this->logs->removeElement($log)) {
1060.             // set the owning side to null (unless already changed)
1061.             if ($log->getMarchand() === $this) {
1062.                 $log->setMarchand(null);
1063.             }
1064.         }
1066.         return $this;
1067.     }
1069.     /**
1070.      * @return Collection<int, Reservation>
1071.      */
1072.     public function getReservations(): Collection
1073.     {
1074.         return $this->reservations;
1075.     }
1077.     public function addReservation(Reservation $reservation): static
1078.     {
1079.         if (!$this->reservations->contains($reservation)) {
1080.             $this->reservations->add($reservation);
1081.             $reservation->setMarchand($this);
1082.         }
1084.         return $this;
1085.     }
1087.     public function removeReservation(Reservation $reservation): static
1088.     {
1089.         if ($this->reservations->removeElement($reservation)) {
1090.             // set the owning side to null (unless already changed)
1091.             if ($reservation->getMarchand() === $this) {
1092.                 $reservation->setMarchand(null);
1093.             }
1094.         }
1096.         return $this;
1097.     }
1099.     /**
1100.      * @return Collection<int, UserEntreprise>
1101.      */
1102.     public function getUserEntreprises(): Collection
1103.     {
1104.         return $this->userEntreprises;
1105.     }
1107.     public function addUserEntreprise(UserEntreprise $userEntreprise): static
1108.     {
1109.         if (!$this->userEntreprises->contains($userEntreprise)) {
1110.             $this->userEntreprises->add($userEntreprise);
1111.             $userEntreprise->setEntreprise($this);
1112.         }
1114.         return $this;
1115.     }
1117.     public function removeUserEntreprise(UserEntreprise $userEntreprise): static
1118.     {
1119.         if ($this->userEntreprises->removeElement($userEntreprise)) {
1120.             // set the owning side to null (unless already changed)
1121.             if ($userEntreprise->getEntreprise() === $this) {
1122.                 $userEntreprise->setEntreprise(null);
1123.             }
1124.         }
1126.         return $this;
1127.     }
1129.     public function getOwner(): ?User
1130.     {
1131.         return $this->owner;
1132.     }
1134.     public function setOwner(?User $owner): static
1135.     {
1136.         $this->owner = $owner;
1138.         return $this;
1139.     }
1141.     public function getDefaultFxRate(): ?string
1142.     {
1143.         return $this->defaultFxRate;
1144.     }
1146.     public function setDefaultFxRate(?string $defaultFxRate): static
1147.     {
1148.         $this->defaultFxRate = $defaultFxRate;
1150.         return $this;
1151.     }
1153.     public function getCurrency(): ?Currency
1154.     {
1155.         return $this->currency;
1156.     }
1158.     public function setCurrency(?Currency $currency): static
1159.     {
1160.         $this->currency = $currency;
1162.         return $this;
1163.     }
1165.     public function isIsDefaultFxRateApply(): ?bool
1166.     {
1167.         return $this->isDefaultFxRateApply;
1168.     }
1170.     public function setIsDefaultFxRateApply(?bool $isDefaultFxRateApply): static
1171.     {
1172.         $this->isDefaultFxRateApply = $isDefaultFxRateApply;
1174.         return $this;
1175.     }
1177.     public function getTva(): ?string
1178.     {
1179.         return $this->tva;
1180.     }
1182.     public function setTva(?string $tva): static
1183.     {
1184.         $this->tva = $tva;
1186.         return $this;
1187.     }
1189.     public function getDgiNif(): ?string
1190.     {
1191.         return $this->dgiNif;
1192.     }
1194.     public function setDgiNif(?string $dgiNif): static
1195.     {
1196.         $this->dgiNif = $dgiNif;
1198.         return $this;
1199.     }
1201.     public function getDgiIsf(): ?string
1202.     {
1203.         return $this->dgiIsf;
1204.     }
1206.     public function setDgiIsf(?string $dgiIsf): static
1207.     {
1208.         $this->dgiIsf = $dgiIsf;
1210.         return $this;
1211.     }
1213.     public function getDgiToken(): ?string
1214.     {
1215.         return $this->dgiToken;
1216.     }
1218.     public function setDgiToken(?string $dgiToken): static
1219.     {
1220.         $this->dgiToken = $dgiToken;
1222.         return $this;
1223.     }
1225.     public function getDgiEnv(): ?string
1226.     {
1227.         return $this->dgiEnv;
1228.     }
1230.     public function setDgiEnv(?string $dgiEnv): static
1231.     {
1232.         $this->dgiEnv = $dgiEnv;
1234.         return $this;
1235.     }
1237.     public function getDgiDefaultTaxGroup(): ?string
1238.     {
1239.         return $this->dgiDefaultTaxGroup;
1240.     }
1242.     public function setDgiDefaultTaxGroup(?string $dgiDefaultTaxGroup): static
1243.     {
1244.         $this->dgiDefaultTaxGroup = $dgiDefaultTaxGroup;
1246.         return $this;
1247.     }
1249.     public function getDgiDefaultItemType(): ?string
1250.     {
1251.         return $this->dgiDefaultItemType;
1252.     }
1254.     public function setDgiDefaultItemType(?string $dgiDefaultItemType): static
1255.     {
1256.         $this->dgiDefaultItemType = $dgiDefaultItemType;
1258.         return $this;
1259.     }
1261.     public function isDgiServiceEnabled(): ?bool
1262.     {
1263.         return $this->dgiServiceEnabled;
1264.     }
1266.     public function setDgiServiceEnabled(?bool $dgiServiceEnabled): static
1267.     {
1268.         $this->dgiServiceEnabled = $dgiServiceEnabled;
1270.         return $this;
1271.     }
1273.     public function getDgiTaxRate(): ?string
1274.     {
1275.         return $this->dgiTaxRate;
1276.     }
1278.     public function setDgiTaxRate(?string $dgiTaxRate): static
1279.     {
1280.         $this->dgiTaxRate = $dgiTaxRate;
1282.         return $this;
1283.     }
1285. }