src/Entity/Department.php line 41

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\GetCollection;
  7. use ApiPlatform\Metadata\Get;
  8. use App\Controller\Api\Establishment\ApiEstablishmentGetByUserController;
  9. use App\Model\Wallet\WalletInterface;
  10. use App\Repository\DepartmentRepository;
  11. use App\State\User\UserEstablishmentDepartementsProvider;
  12. use App\Trait\ActivableTrait;
  13. use App\Trait\AuthorTrait;
  14. use App\Trait\CurrentStateTrait;
  15. use App\Trait\DateTrait;
  16. use App\Trait\DeletableTrait;
  17. use App\Trait\WalletTrait;
  18. use DateTimeImmutable;
  19. use Doctrine\Common\Collections\ArrayCollection;
  20. use Doctrine\Common\Collections\Collection;
  21. use Doctrine\DBAL\Types\Types;
  22. use Doctrine\ORM\Mapping as ORM;
  23. use Symfony\Component\Serializer\Annotation\Groups;
  25. #[ORM\Entity(repositoryClass: DepartmentRepository::class)]
  26. #[ApiResource(
  27.     operations: [
  28.         new GetCollection(
  29.             normalizationContext: ['groups' => ['department:list']]
  30.         ),
  31.         new Get(),
  33.         new GetCollection(
  34.             uriTemplate: 'user/establishments/departments',
  35.             normalizationContext: ['groups' => ['department:list']],
  36.             provider: UserEstablishmentDepartementsProvider::class
  37.         ),
  38.     ],
  39.     normalizationContext: ['groups' => ['department:list', 'department:view']]
  40. )]
  41. class Department implements WalletInterface
  42. {
  43.     use DateTrait {DateTrait::__construct as private dateConstruct;}
  44.     use ActivableTrait;
  45.     use CurrentStateTrait;
  46.     use DeletableTrait;
  47.     use WalletTrait;
  48.     use AuthorTrait;
  50.     #[ORM\Id]
  51.     #[ORM\GeneratedValue]
  52.     #[ORM\Column]
  53.     #[Groups(['department:list', 'article:list', 'order:list'])]
  54.     private ?int $id = null;
  56.     #[ORM\Column(length: 255)]
  57.     #[Groups(['department:list', 'department:new', 'article:list', 'order:list'])]
  58.     private ?string $name = null;
  60.     #[ORM\Column(type: Types::TEXT)]
  61.     #[Groups(['department:view', 'department:new'])]
  62.     private ?string $content = null;
  64.     #[ORM\Column(type: "smallint", options: ["defaults" => 0])]
  65.     #[Groups(['department:list', 'department:view'])]
  66.     private ?int $level = 0;
  68.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'departments')]
  69.     #[Groups(['department:list', 'department:new'])]
  70.     private ?self $parent = null;
  72.     #[ORM\ManyToOne(inversedBy: 'departments')]
  73.     #[ORM\JoinColumn(nullable: false)]
  74.     private ?Establishment $establishment = null;
  76.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  77.     #[Groups(['department:view'])]
  78.     private Collection $departments;
  80.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: Collections::class)]
  81.     private Collection $collections;
  83.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: Order::class, orphanRemoval: true)]
  84.     private Collection $orders;
  86.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: Client::class)]
  87.     private Collection $clients;
  89.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: Employee::class)]
  90.     private Collection $employees;
  92.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: ArticleDepartment::class, orphanRemoval: true)]
  93.     private Collection $articles;
  95.     #[ORM\Column]
  96.     #[Groups(['department:new'])]
  97.     private ?bool $isBookable = null;
  99.     #[ORM\Column]
  100.     #[Groups(['department:new'])]
  101.     private ?bool $hasWallets = null;
  103.     #[ORM\OneToMany(mappedBy: 'department', targetEntity: Lot::class)]
  104.     private Collection $lots;
  106.     #[ORM\Column]
  107.     #[Groups(['department:new'])]
  108.     private ?bool $isOnMenu = false;
  110.     #[ORM\Column(length: 255, nullable: true)]
  111.     #[Groups(['department:new'])]
  112.     private ?string $onMenu = null;
  114.     #[ORM\ManyToMany(targetEntity: Planning::class, mappedBy: 'departments')]
  115.     private Collection $plannings;
  117.     public function __construct()
  118.     {
  119.         $this->currentState = 'draft';
  120.         $this->dateConstruct();
  122.         $this->departments = new ArrayCollection();
  123.         $this->orders = new ArrayCollection();
  124.         $this->clients = new ArrayCollection();
  125.         $this->employees = new ArrayCollection();
  126.         $this->articles = new ArrayCollection();
  127.         $this->lots = new ArrayCollection();
  128.     }
  130.     public function getId(): ?int
  131.     {
  132.         return $this->id;
  133.     }
  135.     public function getName(): ?string
  136.     {
  137.         return $this->name;
  138.     }
  140.     public function setName(string $name): self
  141.     {
  142.         $this->name = $name;
  144.         return $this;
  145.     }
  147.     public function getContent(): ?string
  148.     {
  149.         return $this->content;
  150.     }
  152.     public function setContent(string $content): self
  153.     {
  154.         $this->content = $content;
  156.         return $this;
  157.     }
  159.     public function getLevel(): ?int
  160.     {
  161.         return $this->level;
  162.     }
  164.     public function setLevel(int $level): self
  165.     {
  166.         $this->level = $level;
  168.         return $this;
  169.     }
  171.     public function getParent(): ?self
  172.     {
  173.         return $this->parent;
  174.     }
  176.     public function setParent(?self $parent): self
  177.     {
  178.         $this->parent = $parent;
  180.         return $this;
  181.     }
  183.     public function getEstablishment(): ?Establishment
  184.     {
  185.         return $this->establishment;
  186.     }
  188.     public function setEstablishment(?Establishment $establishment): self
  189.     {
  190.         $this->establishment = $establishment;
  192.         return $this;
  193.     }
  195.     /**
  196.      * @return Collection<int, self>
  197.      */
  198.     public function getDepartments(): Collection
  199.     {
  200.         return $this->departments;
  201.     }
  203.     public function addDepartment(self $department): self
  204.     {
  205.         if (!$this->departments->contains($department)) {
  206.             $this->departments->add($department);
  207.             $department->setParent($this);
  208.         }
  210.         return $this;
  211.     }
  213.     public function removeDepartment(self $department): self
  214.     {
  215.         if ($this->departments->removeElement($department)) {
  216.             // set the owning side to null (unless already changed)
  217.             if ($department->getParent() === $this) {
  218.                 $department->setParent(null);
  219.             }
  220.         }
  222.         return $this;
  223.     }
  225.     /**
  226.      * @return Collection<int, Order>
  227.      */
  228.     public function getOrders(): Collection
  229.     {
  230.         return $this->orders;
  231.     }
  233.     public function addOrder(Order $order): self
  234.     {
  235.         if (!$this->orders->contains($order)) {
  236.             $this->orders->add($order);
  237.             $order->setDepartment($this);
  238.         }
  240.         return $this;
  241.     }
  243.     public function removeOrder(Order $order): self
  244.     {
  245.         if ($this->orders->removeElement($order)) {
  246.             // set the owning side to null (unless already changed)
  247.             if ($order->getDepartment() === $this) {
  248.                 $order->setDepartment(null);
  249.             }
  250.         }
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Client>
  257.      */
  258.     public function getClients(): Collection
  259.     {
  260.         return $this->clients;
  261.     }
  263.     public function addClient(Client $client): self
  264.     {
  265.         if (!$this->clients->contains($client)) {
  266.             $this->clients->add($client);
  267.             $client->setDepartment($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeClient(Client $client): self
  274.     {
  275.         if ($this->clients->removeElement($client)) {
  276.             // set the owning side to null (unless already changed)
  277.             if ($client->getDepartment() === $this) {
  278.                 $client->setDepartment(null);
  279.             }
  280.         }
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection<int, Employee>
  287.      */
  288.     public function getEmployees(): Collection
  289.     {
  290.         return $this->employees;
  291.     }
  293.     public function addEmployee(Employee $employee): self
  294.     {
  295.         if (!$this->employees->contains($employee)) {
  296.             $this->employees->add($employee);
  297.             $employee->setDepartment($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeEmployee(Employee $employee): self
  304.     {
  305.         if ($this->employees->removeElement($employee)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($employee->getDepartment() === $this) {
  308.                 $employee->setDepartment(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     /**
  316.      * @return Collection<int, ArticleDepartment>
  317.      */
  318.     public function getArticles(): Collection
  319.     {
  320.         return $this->articles;
  321.     }
  323.     public function addArticle(ArticleDepartment $article): self
  324.     {
  325.         if (!$this->articles->contains($article)) {
  326.             $this->articles->add($article);
  327.             $article->setDepartment($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeArticle(ArticleDepartment $article): self
  334.     {
  335.         if ($this->articles->removeElement($article)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($article->getDepartment() === $this) {
  338.                 $article->setDepartment(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     public function __serialize(): array
  346.     {
  347.         return [$this->id, $this->name];
  348.     }
  350.     public function __unserialize(array $data): void
  351.     {
  352.         if (count($data) === 4) [$this->id, $this->name] = $data;
  353.     }
  355.     public function isIsBookable(): ?bool
  356.     {
  357.         return $this->isBookable;
  358.     }
  360.     public function setIsBookable(bool $isBookable): self
  361.     {
  362.         $this->isBookable = $isBookable;
  364.         return $this;
  365.     }
  367.     public function isHasWallets(): ?bool
  368.     {
  369.         return $this->hasWallets;
  370.     }
  372.     public function setHasWallets(bool $hasWallets): self
  373.     {
  374.         $this->hasWallets = $hasWallets;
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection<int, Lot>
  381.      */
  382.     public function getLots(): Collection
  383.     {
  384.         return $this->lots;
  385.     }
  387.     public function addLot(Lot $lot): self
  388.     {
  389.         if (!$this->lots->contains($lot)) {
  390.             $this->lots->add($lot);
  391.             $lot->setDepartment($this);
  392.         }
  394.         return $this;
  395.     }
  397.     public function removeLot(Lot $lot): self
  398.     {
  399.         if ($this->lots->removeElement($lot)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($lot->getDepartment() === $this) {
  402.                 $lot->setDepartment(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     public function isIsOnMenu(): ?bool
  410.     {
  411.         return $this->isOnMenu;
  412.     }
  414.     public function setIsOnMenu(bool $isOnMenu): self
  415.     {
  416.         $this->isOnMenu = $isOnMenu;
  418.         return $this;
  419.     }
  421.     public function getOnMenu(): ?string
  422.     {
  423.         return $this->onMenu;
  424.     }
  426.     public function setOnMenu(?string $onMenu): self
  427.     {
  428.         $this->onMenu = $onMenu;
  430.         return $this;
  431.     }
  433.     public function increaseLevel(?int $param)
  434.     {
  435.     }
  437.     /**
  438.      * @return Collection<int, Planning>
  439.      */
  440.     public function getPlannings(): Collection
  441.     {
  442.         return $this->plannings;
  443.     }
  445.     public function addPlanning(Planning $planning): static
  446.     {
  447.         if (!$this->plannings->contains($planning)) {
  448.             $this->plannings->add($planning);
  449.             $planning->addDepartment($this);
  450.         }
  452.         return $this;
  453.     }
  455.     public function removePlanning(Planning $planning): static
  456.     {
  457.         if ($this->plannings->removeElement($planning)) {
  458.             $planning->removeDepartment($this);
  459.         }
  461.         return $this;
  462.     }
  464.     public function __toString(): string
  465.     {
  466.         $departmentParent = $this->getParent();
  467.         $departmentParent = $departmentParent ? " [$departmentParent]" : "";
  468.         return $this->name . $departmentParent;
  469.     }
  470. }