src/Entity/Entreprise.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EntrepriseRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: EntrepriseRepository::class)]
  12. #[ORM\Table(name: '_admin_param_entreprise')]
  13. class Entreprise
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column(length: 255)]
  21.     private ?string $denomination = null;
  23.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Employe::class)]
  24.     private Collection $employes;
  26.     #[ORM\Column(length: 255)]
  27.     private ?string $code = null;
  29.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: ConfigApp::class)]
  30.     private Collection $configApps;
  32.     #[ORM\Column(length: 255, nullable: true)]
  33.     private ?string $Sigle = null;
  35.     #[ORM\Column(length: 255, nullable: true)]
  36.     private ?string $Agrements = null;
  39.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  40.     private ?string $situation_geo = null;
  42.     #[ORM\Column(length: 255)]
  43.     private ?string $contacts = null;
  45.     #[ORM\Column(length: 255, nullable: true)]
  46.     private ?string $adresse = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $mobile = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $fax = null;
  55.     #[ORM\Column(length: 255)]
  56.     private ?string $email = null;
  58.     #[ORM\ManyToOne(cascade: ["persist"], fetch: "EAGER")]
  59.     #[ORM\JoinColumn(nullable: true)]
  60.     private ?FichierAdmin $logo = null;
  63.     #[ORM\Column(length: 255)]
  64.     private ?string $site_web = null;
  66.     #[ORM\Column(length: 255, nullable: true)]
  67.     private ?string $Directeur = null;
  70.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  71.     private ?\DateTimeInterface $dateCreation = null;
  73.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: CourierArrive::class)]
  74.     private Collection $courierArrives;
  76.    
  78.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Fonction::class)]
  79.     private Collection $fonctions;
  83.     #[ORM\OneToMany(mappedBy: 'entreprise', targetEntity: Calendar::class)]
  84.     private Collection $calendars;
  90.     public function __construct()
  91.     {
  92.         $this->employes = new ArrayCollection();
  93.         $this->configApps = new ArrayCollection();
  94.         $this->courierArrives = new ArrayCollection();
  95.         // $this->dossiers = new ArrayCollection();
  96.         $this->fonctions = new ArrayCollection();
  97.         // $this->clients = new ArrayCollection();
  98.         // $this->acteConstitutions = new ArrayCollection();
  99.         // $this->archives = new ArrayCollection();
  100.         $this->calendars = new ArrayCollection();
  101.     }
  103.     public function getId(): ?int
  104.     {
  105.         return $this->id;
  106.     }
  108.     public function getDenomination(): ?string
  109.     {
  110.         return $this->denomination;
  111.     }
  113.     public function setDenomination(string $denomination): self
  114.     {
  115.         $this->denomination = $denomination;
  117.         return $this;
  118.     }
  120.     /**
  121.      * @return Collection<int, Employe>
  122.      */
  123.     public function getEmployes(): Collection
  124.     {
  125.         return $this->employes;
  126.     }
  128.     public function addEmploye(Employe $employe): self
  129.     {
  130.         if (!$this->employes->contains($employe)) {
  131.             $this->employes->add($employe);
  132.             $employe->setEntreprise($this);
  133.         }
  135.         return $this;
  136.     }
  138.     public function removeEmploye(Employe $employe): self
  139.     {
  140.         if ($this->employes->removeElement($employe)) {
  141.             // set the owning side to null (unless already changed)
  142.             if ($employe->getEntreprise() === $this) {
  143.                 $employe->setEntreprise(null);
  144.             }
  145.         }
  147.         return $this;
  148.     }
  150.     public function getCode(): ?string
  151.     {
  152.         return $this->code;
  153.     }
  155.     public function setCode(string $code): self
  156.     {
  157.         $this->code = $code;
  159.         return $this;
  160.     }
  162.     /**
  163.      * @return Collection<int, ConfigApp>
  164.      */
  165.     public function getConfigApps(): Collection
  166.     {
  167.         return $this->configApps;
  168.     }
  170.     public function addConfigApp(ConfigApp $configApp): static
  171.     {
  172.         if (!$this->configApps->contains($configApp)) {
  173.             $this->configApps->add($configApp);
  174.             $configApp->setEntreprise($this);
  175.         }
  177.         return $this;
  178.     }
  180.     public function removeConfigApp(ConfigApp $configApp): static
  181.     {
  182.         if ($this->configApps->removeElement($configApp)) {
  183.             // set the owning side to null (unless already changed)
  184.             if ($configApp->getEntreprise() === $this) {
  185.                 $configApp->setEntreprise(null);
  186.             }
  187.         }
  189.         return $this;
  190.     }
  195.     public function getSigle(): ?string
  196.     {
  197.         return $this->Sigle;
  198.     }
  200.     public function setSigle(string $Sigle): static
  201.     {
  202.         $this->Sigle = $Sigle;
  204.         return $this;
  205.     }
  207.     public function getAgrements(): ?string
  208.     {
  209.         return $this->Agrements;
  210.     }
  212.     public function setAgrements(string $Agrements): static
  213.     {
  214.         $this->Agrements = $Agrements;
  216.         return $this;
  217.     }
  220.     public function getSituationGeo(): ?string
  221.     {
  222.         return $this->situation_geo;
  223.     }
  225.     public function setSituationGeo(string $situation_geo): static
  226.     {
  227.         $this->situation_geo = $situation_geo;
  229.         return $this;
  230.     }
  232.     public function getContacts(): ?string
  233.     {
  234.         return $this->contacts;
  235.     }
  237.     public function setContacts(string $contacts): static
  238.     {
  239.         $this->contacts = $contacts;
  241.         return $this;
  242.     }
  244.     public function getAdresse(): ?string
  245.     {
  246.         return $this->adresse;
  247.     }
  249.     public function setAdresse(string $adresse): static
  250.     {
  251.         $this->adresse = $adresse;
  253.         return $this;
  254.     }
  259.     public function getMobile(): ?string
  260.     {
  261.         return $this->mobile;
  262.     }
  264.     public function setMobile(string $mobile): static
  265.     {
  266.         $this->mobile = $mobile;
  268.         return $this;
  269.     }
  271.     public function getFax(): ?string
  272.     {
  273.         return $this->fax;
  274.     }
  276.     public function setFax(string $fax): static
  277.     {
  278.         $this->fax = $fax;
  280.         return $this;
  281.     }
  283.     public function getEmail(): ?string
  284.     {
  285.         return $this->email;
  286.     }
  288.     public function setEmail(string $email): static
  289.     {
  290.         $this->email = $email;
  292.         return $this;
  293.     }
  295.     public function getLogo(): ?FichierAdmin
  296.     {
  297.         return $this->logo;
  298.     }
  300.     public function setLogo(FichierAdmin $logo): static
  301.     {
  302.         $this->logo = $logo;
  304.         return $this;
  305.     }
  307.     public function getSiteWeb(): ?string
  308.     {
  309.         return $this->site_web;
  310.     }
  312.     public function setSiteWeb(string $site_web): static
  313.     {
  314.         $this->site_web = $site_web;
  316.         return $this;
  317.     }
  319.     public function getDirecteur(): ?string
  320.     {
  321.         return $this->Directeur;
  322.     }
  324.     public function setDirecteur(string $Directeur): static
  325.     {
  326.         $this->Directeur = $Directeur;
  328.         return $this;
  329.     }
  331.     public function getDateCreation(): ?\DateTimeInterface
  332.     {
  333.         return $this->dateCreation;
  334.     }
  336.     public function setDateCreation(\DateTimeInterface $dateCreation): static
  337.     {
  338.         $this->dateCreation = $dateCreation;
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, CourierArrive>
  345.      */
  346.     public function getCourierArrives(): Collection
  347.     {
  348.         return $this->courierArrives;
  349.     }
  351.     public function addCourierArrife(CourierArrive $courierArrife): static
  352.     {
  353.         if (!$this->courierArrives->contains($courierArrife)) {
  354.             $this->courierArrives->add($courierArrife);
  355.             $courierArrife->setEntreprise($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeCourierArrife(CourierArrive $courierArrife): static
  362.     {
  363.         if ($this->courierArrives->removeElement($courierArrife)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($courierArrife->getEntreprise() === $this) {
  366.                 $courierArrife->setEntreprise(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     // /**
  374.     //  * @return Collection<int, Dossier>
  375.     //  */
  376.     // public function getDossiers(): Collection
  377.     // {
  378.     //     return $this->dossiers;
  379.     // }
  381.     // public function addDossier(Dossier $dossier): static
  382.     // {
  383.     //     if (!$this->dossiers->contains($dossier)) {
  384.     //         $this->dossiers->add($dossier);
  385.     //         $dossier->setEntreprise($this);
  386.     //     }
  388.     //     return $this;
  389.     // }
  391.     // public function removeDossier(Dossier $dossier): static
  392.     // {
  393.     //     if ($this->dossiers->removeElement($dossier)) {
  394.     //         // set the owning side to null (unless already changed)
  395.     //         if ($dossier->getEntreprise() === $this) {
  396.     //             $dossier->setEntreprise(null);
  397.     //         }
  398.     //     }
  400.     //     return $this;
  401.     // }
  403.     /**
  404.      * @return Collection<int, Fonction>
  405.      */
  406.     public function getFonctions(): Collection
  407.     {
  408.         return $this->fonctions;
  409.     }
  411.     public function addFonction(Fonction $fonction): static
  412.     {
  413.         if (!$this->fonctions->contains($fonction)) {
  414.             $this->fonctions->add($fonction);
  415.             $fonction->setEntreprise($this);
  416.         }
  418.         return $this;
  419.     }
  421.     public function removeFonction(Fonction $fonction): static
  422.     {
  423.         if ($this->fonctions->removeElement($fonction)) {
  424.             // set the owning side to null (unless already changed)
  425.             if ($fonction->getEntreprise() === $this) {
  426.                 $fonction->setEntreprise(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     // /**
  434.     //  * @return Collection<int, Client>
  435.     //  */
  436.     // public function getClients(): Collection
  437.     // {
  438.     //     return $this->clients;
  439.     // }
  441.     // public function addClient(Client $client): static
  442.     // {
  443.     //     if (!$this->clients->contains($client)) {
  444.     //         $this->clients->add($client);
  445.     //         $client->setEntreprise($this);
  446.     //     }
  448.     //     return $this;
  449.     // }
  451.     // public function removeClient(Client $client): static
  452.     // {
  453.     //     if ($this->clients->removeElement($client)) {
  454.     //         // set the owning side to null (unless already changed)
  455.     //         if ($client->getEntreprise() === $this) {
  456.     //             $client->setEntreprise(null);
  457.     //         }
  458.     //     }
  460.     //     return $this;
  461.     // }
  463.     // /**
  464.     //  * @return Collection<int, ActeConstitution>
  465.     //  */
  466.     // public function getActeConstitutions(): Collection
  467.     // {
  468.     //     return $this->acteConstitutions;
  469.     // }
  471.     // public function addActeConstitution(ActeConstitution $acteConstitution): static
  472.     // {
  473.     //     if (!$this->acteConstitutions->contains($acteConstitution)) {
  474.     //         $this->acteConstitutions->add($acteConstitution);
  475.     //         $acteConstitution->setEntreprise($this);
  476.     //     }
  478.     //     return $this;
  479.     // }
  481.     // public function removeActeConstitution(ActeConstitution $acteConstitution): static
  482.     // {
  483.     //     if ($this->acteConstitutions->removeElement($acteConstitution)) {
  484.     //         // set the owning side to null (unless already changed)
  485.     //         if ($acteConstitution->getEntreprise() === $this) {
  486.     //             $acteConstitution->setEntreprise(null);
  487.     //         }
  488.     //     }
  490.     //     return $this;
  491.     // }
  493.     // /**
  494.     //  * @return Collection<int, Archive>
  495.     //  */
  496.     // public function getArchives(): Collection
  497.     // {
  498.     //     return $this->archives;
  499.     // }
  501.     // public function addArchive(Archive $archive): static
  502.     // {
  503.     //     if (!$this->archives->contains($archive)) {
  504.     //         $this->archives->add($archive);
  505.     //         $archive->setEntreprise($this);
  506.     //     }
  508.     //     return $this;
  509.     // }
  511.     // public function removeArchive(Archive $archive): static
  512.     // {
  513.     //     if ($this->archives->removeElement($archive)) {
  514.     //         // set the owning side to null (unless already changed)
  515.     //         if ($archive->getEntreprise() === $this) {
  516.     //             $archive->setEntreprise(null);
  517.     //         }
  518.     //     }
  520.     //     return $this;
  521.     // }
  523.     /**
  524.      * @return Collection<int, Calendar>
  525.      */
  526.     public function getCalendars(): Collection
  527.     {
  528.         return $this->calendars;
  529.     }
  531.     public function addCalendar(Calendar $calendar): static
  532.     {
  533.         if (!$this->calendars->contains($calendar)) {
  534.             $this->calendars->add($calendar);
  535.             $calendar->setEntreprise($this);
  536.         }
  538.         return $this;
  539.     }
  541.     public function removeCalendar(Calendar $calendar): static
  542.     {
  543.         if ($this->calendars->removeElement($calendar)) {
  544.             // set the owning side to null (unless already changed)
  545.             if ($calendar->getEntreprise() === $this) {
  546.                 $calendar->setEntreprise(null);
  547.             }
  548.         }
  550.         return $this;
  551.     }
  552. }