src/Entity/Employee.php line 47

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\GetCollection;
  7. use ApiPlatform\Metadata\Get;
  8. use ApiPlatform\Metadata\Link;
  9. use App\Controller\Api\Employee\ApiEstablishmentEmployeeStatsController;
  10. use App\Controller\Api\Order\ApiEmployeeOrdersController;
  11. use App\Kimia;
  12. use App\Model\Wallet\WalletInterface;
  13. use App\Repository\EmployeeRepository;
  14. use App\Trait\ActivableTrait;
  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: EmployeeRepository::class)]
  26. #[ApiResource(
  27.     operations: [
  28.         new GetCollection(
  29.             normalizationContext: ['groups' => ['employee:list']]
  30.         ),
  31.         new GetCollection(
  32.             uriTemplate: "/departments/{departmentId}/employees",
  33.             uriVariables: [
  34.                 'departmentId' => new Link(toProperty: 'department', fromClass: Department::class),
  35.             ],
  36.             normalizationContext: ['groups' => ['employee:list']]
  37.         ),
  38.         new Get(),
  39.         new Get(
  40.             uriTemplate: "/employees/{id}/stats",
  41.             controller: ApiEstablishmentEmployeeStatsController::class,
  42.             normalizationContext: ['groups' => ['order:list']]
  43.         ),
  44.     ],
  45.     normalizationContext: ['groups' => ['employee:list', 'employee:view']]
  46. )]
  47. class Employee implements WalletInterface
  48. {
  49.     use DateTrait {
  50.         DateTrait::__construct as dateConstruct;
  51.     }
  52.     use ActivableTrait;
  53.     use DeletableTrait;
  54.     use WalletTrait;
  56.     #[ORM\Id]
  57.     #[ORM\GeneratedValue]
  58.     #[ORM\Column]
  59.     #[Groups(['employee:list', 'flow:list', 'attendance:list'])]
  60.     private ?int $id = null;
  62.     #[ORM\Column(length: 255)]
  63.     #[Groups(['employee:list', 'flow:list', 'attendance:list'])]
  64.     private ?string $firstname = null;
  66.     #[ORM\Column(length: 255)]
  67.     #[Groups(['employee:list', 'flow:list', 'attendance:list'])]
  68.     private ?string $lastname = null;
  70.     #[ORM\Column(length: 180, nullable: true)]
  71.     #[Groups(['employee:list', 'flow:list', 'attendance:list'])]
  72.     private ?string $email = null;
  74.     #[ORM\Column(length: 15)]
  75.     #[Groups(['employee:list', 'flow:list', 'attendance:list'])]
  76.     private ?string $phone = null;
  78.     #[ORM\Column(type: Types::JSON)]
  79.     #[Groups(['employee:view'])]
  80.     private array $permissions = [];
  82.     #[ORM\Column(length: 255)]
  83.     private ?string $status;
  85.     #[ORM\ManyToOne(cascade: ["persist"])]
  86.     #[ORM\JoinColumn(nullable: true)]
  87.     private ?Invitation $invitation = null;
  89.     #[ORM\ManyToOne]
  90.     private ?User $user = null;
  92.     #[ORM\ManyToOne(inversedBy: 'employees')]
  93.     private ?Department $department = null;
  95.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: Attendance::class, orphanRemoval: true)]
  96.     private Collection $attendances;
  98.     #[ORM\OneToMany(mappedBy: 'waiter', targetEntity: Order::class)]
  99.     private Collection $orders;
  101.     #[ORM\Column]
  102.     private ?int $quota;
  104.     #[ORM\ManyToOne(inversedBy: 'employees')]
  105.     private ?Establishment $establishment = null;
  107.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: FlowUser::class)]
  108.     private Collection $flowUsers;
  110.     #[ORM\Column]
  111.     private ?bool $paymentQuota = null;
  113.     #[ORM\Column(nullable: true)]
  114.     private ?float $percentQuota = null;
  116.     #[ORM\ManyToOne(inversedBy: 'employees')]
  117.     private ?Role $function = null;
  119.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: Document::class)]
  120.     private Collection $documents;
  122.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: EmployeeContract::class, orphanRemoval: true)]
  123.     private Collection $contracts;
  125.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: Address::class)]
  126.     private Collection $addresses;
  128.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: Card::class)]
  129.     private Collection $cards;
  131.     #[ORM\OneToMany(mappedBy: 'employee', targetEntity: Mutuality::class)]
  132.     private Collection $mutualities;
  134.     public function __construct()
  135.     {
  136.         $this->dateConstruct();
  137.         $this->quota = 0;
  138.         $this->attendances = new ArrayCollection();
  139.         $this->orders = new ArrayCollection();
  140.         $this->flowUsers = new ArrayCollection();
  141.         $this->documents = new ArrayCollection();
  142.         $this->contracts = new ArrayCollection();
  143.         $this->addresses = new ArrayCollection();
  144.         $this->cards = new ArrayCollection();
  145.         $this->mutualities = new ArrayCollection();
  146.     }
  148.     public function getId(): ?int
  149.     {
  150.         return $this->id;
  151.     }
  153.     public function getFullname(): ?string
  154.     {
  155.         return "$this->firstname $this->lastname";
  156.     }
  158.     public function getName(): ?string
  159.     {
  160.         return "$this->firstname $this->lastname";
  161.     }
  163.     public function getFirstname(): ?string
  164.     {
  165.         return $this->firstname;
  166.     }
  168.     public function setFirstname(string $firstname): self
  169.     {
  170.         $this->firstname = $firstname;
  172.         return $this;
  173.     }
  175.     public function getLastname(): ?string
  176.     {
  177.         return $this->lastname;
  178.     }
  180.     public function setLastname(string $lastname): self
  181.     {
  182.         $this->lastname = $lastname;
  184.         return $this;
  185.     }
  187.     public function getEmail(): ?string
  188.     {
  189.         return $this->email;
  190.     }
  192.     public function setEmail(?string $email): self
  193.     {
  194.         $this->email = $email;
  196.         return $this;
  197.     }
  199.     public function getPhone(): ?string
  200.     {
  201.         return $this->phone;
  202.     }
  204.     public function setPhone(string $phone): self
  205.     {
  206.         $this->phone = preg_replace('/^(\+243|0|00243)([0-9]{9})$/', '243$2', $phone);
  208.         return $this;
  209.     }
  211.     public function getPermissions(): array
  212.     {
  213.         return $this->permissions;
  214.     }
  216.     public static function getPermissionList(): array
  217.     {
  218.         return [
  219.             "Voir les départements" => Kimia::ROLE_VIEW_DEPARTMENT,
  220.             "Créer les départements" => Kimia::ROLE_CREATE_DEPARTMENT,
  221.             "Modifier les départements" => Kimia::ROLE_EDIT_DEPARTMENT,
  222.             "Supprimer les départements" => Kimia::ROLE_DELETE_DEPARTMENT,
  223.             "Activer les départements" => Kimia::ROLE_ACTIVATE_DEPARTMENT,
  224.             "Désactiver les départements" => Kimia::ROLE_DEACTIVATE_DEPARTMENT,
  225.             "Voir les articles" => Kimia::ROLE_VIEW_ARTICLE,
  226.             "Créer les articles" => Kimia::ROLE_CREATE_ARTICLE,
  227.             "Modifier les articles" => Kimia::ROLE_EDIT_ARTICLE,
  228.             "Supprimer les articles" => Kimia::ROLE_DELETE_ARTICLE,
  229.             "Activer les articles" => Kimia::ROLE_ACTIVATE_ARTICLE,
  230.             "Désactiver les articles" => Kimia::ROLE_DEACTIVATE_ARTICLE,
  231.             "Voir les collections" => Kimia::ROLE_VIEW_COLLECTION,
  232.             "Créer les collections" => Kimia::ROLE_CREATE_COLLECTION,
  233.             "Modifier les collections" => Kimia::ROLE_EDIT_COLLECTION,
  234.             "Supprimer les collections" => Kimia::ROLE_DELETE_COLLECTION,
  235.             "Activer les collections" => Kimia::ROLE_ACTIVATE_COLLECTION,
  236.             "Désactiver les collections" => Kimia::ROLE_DEACTIVATE_COLLECTION,
  237.             "Gérer les finances" => Kimia::ROLE_VIEW_FINANCE,
  238.             "Analyser les données" => Kimia::ROLE_VIEW_DATA_ANALYST,
  239.             "Voir le profile" => Kimia::ROLE_VIEW_PROFILE,
  240.             "Voir les réductions" => Kimia::ROLE_VIEW_REDUCTION,
  241.             "Créer les réductions" => Kimia::ROLE_CREATE_REDUCTION,
  242.             "Modifier les réductions" => Kimia::ROLE_EDIT_REDUCTION,
  243.             "Supprimer les réductions" => Kimia::ROLE_DELETE_REDUCTION,
  244.             "Activer les réductions" => Kimia::ROLE_ACTIVATE_REDUCTION,
  245.             "Desactiver les réductions" => Kimia::ROLE_DEACTIVATE_REDUCTION,
  246.             "Voir les stocks" => Kimia::ROLE_VIEW_STOCK,
  247.             "Créer les stocks" => Kimia::ROLE_CREATE_STOCK,
  248.             "Modifier les stocks" => Kimia::ROLE_EDIT_STOCK,
  249.             "Supprimer les stocks" => Kimia::ROLE_DELETE_STOCK,
  250.             "Approuver les stocks" => Kimia::ROLE_APPROVE_STOCK,
  251.             "Annuler les stocks" => Kimia::ROLE_CANCEL_STOCK,
  252.             "Voir les commandes" => Kimia::ROLE_VIEW_ORDER,
  253.             "Créer les commandes" => Kimia::ROLE_CREATE_ORDER,
  254.             "Modifier les commandes" => Kimia::ROLE_EDIT_ORDER,
  255.             "Supprimer les commandes" => Kimia::ROLE_DELETE_ORDER,
  256.             "Annuler les commandes" => Kimia::ROLE_CANCEL_ORDER,
  257.             "Voir les planning" => Kimia::ROLE_VIEW_PLANNING,
  258.             "Créer les planning" => Kimia::ROLE_CREATE_PLANNING,
  259.             "Modifier les planning" => Kimia::ROLE_EDIT_PLANNING,
  260.             "Supprimer les planning" => Kimia::ROLE_DELETE_PLANNING,
  261.             "Activer les planning" => Kimia::ROLE_ACTIVATE_PLANNING,
  262.             "Désactiver les planning" => Kimia::ROLE_DEACTIVATE_PLANNING,
  263.             "Voir les employés" => Kimia::ROLE_VIEW_EMPLOYEE,
  264.             "Ajouter des employés" => Kimia::ROLE_CREATE_EMPLOYEE,
  265.             "Modifier des employés" => Kimia::ROLE_EDIT_EMPLOYEE,
  266.             "Supprimer des employés" => Kimia::ROLE_DELETE_EMPLOYEE,
  267.             "Voir les clients" => Kimia::ROLE_VIEW_CLIENT,
  268.             "Créer les clients" => Kimia::ROLE_CREATE_CLIENT,
  269.             "Modifier les clients" => Kimia::ROLE_EDIT_CLIENT,
  270.             "Supprimer les clients" => Kimia::ROLE_DELETE_CLIENT,
  271.             "Voir les présences" => Kimia::ROLE_VIEW_PRESENCE,
  272.             "Créer les présences" => Kimia::ROLE_CREATE_PRESENCE,
  273.             "Modifier les présences" => Kimia::ROLE_EDIT_PRESENCE,
  274.             "Supprimer les présences" => Kimia::ROLE_DELETE_PRESENCE,
  275.             "Voir les modèles des factures" => Kimia::ROLE_VIEW_FACTURE,
  276.             "Créer les modèles des factures" => Kimia::ROLE_CREATE_FACTURE,
  277.             "Modifier les modèles des factures" => Kimia::ROLE_EDIT_FACTURE,
  278.             "Supprimer les modèles des factures" => Kimia::ROLE_DELETE_FACTURE,
  279.             "Serveur" => Kimia::ROLE_WAITER,
  280.         ];
  281.     }
  283.     public static function getGroupPermissionList(): array
  284.     {
  285.         return [
  286.             Kimia::GROUP_ROLE_DEPARTMENT => Kimia::GROUP_ROLE_DEPARTMENT_LIST,
  287.             Kimia::GROUP_ROLE_ARTICLE => Kimia::GROUP_ROLE_ARTICLE_LIST,
  288.             Kimia::GROUP_ROLE_COLLECTION => Kimia::GROUP_ROLE_COLLECTION_LIST,
  289.             Kimia::GROUP_ROLE_REDUCTION => Kimia::GROUP_ROLE_REDUCTION_LIST,
  290.             Kimia::GROUP_ROLE_STOCK => Kimia::GROUP_ROLE_STOCK_LIST,
  291.             Kimia::GROUP_ROLE_ORDER => Kimia::GROUP_ROLE_ORDER_LIST,
  292.             Kimia::GROUP_ROLE_PLANNING => Kimia::GROUP_ROLE_PLANNING_LIST,
  293.             Kimia::GROUP_ROLE_EMPLOYEE => Kimia::GROUP_ROLE_EMPLOYEE_LIST,
  294.             Kimia::GROUP_ROLE_CLIENT => Kimia::GROUP_ROLE_CLIENT_LIST,
  295.             Kimia::GROUP_ROLE_PRESENCE => Kimia::GROUP_ROLE_PRESENCE_LIST,
  296.             Kimia::GROUP_ROLE_FACTURE => Kimia::GROUP_ROLE_FACTURE_LIST
  297.         ];
  298.     }
  300.     public function setPermissions(array $permissions): self
  301.     {
  302.         $this->permissions = $permissions;
  304.         return $this;
  305.     }
  307.     public function getIsGranted($role)
  308.     {
  309.         if (in_array($role, $this->getPermissions())) return true;
  311.         return false;
  312.     }
  314.     public function getIsGrantedGroup($group)
  315.     {
  316.         foreach (self::getGroupPermissionList()[$group] as $r) {
  317.             if (in_array($r, $this->getPermissions())) return true;
  318.         }
  320.         return false;
  321.     }
  323.     public function getStatus(): ?string
  324.     {
  325.         return $this->status;
  326.     }
  328.     public function setStatus(string $status): self
  329.     {
  330.         $this->status = $status;
  332.         return $this;
  333.     }
  335.     public function getInvitation(): ?Invitation
  336.     {
  337.         return $this->invitation;
  338.     }
  340.     public function setInvitation(?Invitation $invitation): self
  341.     {
  342.         $this->invitation = $invitation;
  344.         return $this;
  345.     }
  347.     public function getUser(): ?User
  348.     {
  349.         return $this->user;
  350.     }
  352.     public function setUser(?User $user): self
  353.     {
  354.         $this->user = $user;
  356.         return $this;
  357.     }
  359.     public function getDepartment(): ?Department
  360.     {
  361.         return $this->department;
  362.     }
  364.     public function setDepartment(?Department $department): self
  365.     {
  366.         $this->department = $department;
  368.         return $this;
  369.     }
  371.     /**
  372.      * @return Collection<int, Attendance>
  373.      */
  374.     public function getAttendances(): Collection
  375.     {
  376.         return $this->attendances;
  377.     }
  379.     public function addAttendance(Attendance $attendance): self
  380.     {
  381.         if (!$this->attendances->contains($attendance)) {
  382.             $this->attendances->add($attendance);
  383.             $attendance->setEmployee($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeAttendance(Attendance $attendance): self
  390.     {
  391.         if ($this->attendances->removeElement($attendance)) {
  392.             if ($attendance->getEmployee() === $this) {
  393.                 $attendance->setEmployee(null);
  394.             }
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection<int, Order>
  402.      */
  403.     public function getOrders(): Collection
  404.     {
  405.         return $this->orders;
  406.     }
  408.     public function addOrder(Order $order): self
  409.     {
  410.         if (!$this->orders->contains($order)) {
  411.             $this->orders->add($order);
  412.             $order->setWaiter($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeOrder(Order $order): self
  419.     {
  420.         if ($this->orders->removeElement($order)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($order->getWaiter() === $this) {
  423.                 $order->setWaiter(null);
  424.             }
  425.         }
  427.         return $this;
  428.     }
  430.     public function getQuota(): ?int
  431.     {
  432.         return $this->quota;
  433.     }
  435.     public function incrementQuota(int $quota = 1): self
  436.     {
  437.         $this->quota += $quota;
  438.         return $this;
  439.     }
  441.     public function decrementQuota(int $quota = 1): self
  442.     {
  443.         $this->quota -= $quota;
  444.         return $this;
  445.     }
  447.     public function getQuotaOfDay(): ?int
  448.     {
  449.         $quota = 0;
  451.         $now = new DateTimeImmutable();
  452.         /** @var Order $order */
  453.         foreach ($this->orders as $order) {
  454.             if ($order->getCreatedAt()->format('d M Y') === $now->format('d M Y')) {
  455.                 if ($order->getStatus() === Kimia::STATUS_SUCCESS) $quota++;
  456.             }
  457.         }
  459.         return $quota;
  460.     }
  462.     public function setQuota(int $quota): self
  463.     {
  464.         $this->quota = $quota;
  466.         return $this;
  467.     }
  469.     public function getEstablishment(): ?Establishment
  470.     {
  471.         return $this->establishment;
  472.     }
  474.     public function setEstablishment(?Establishment $establishment): self
  475.     {
  476.         $this->establishment = $establishment;
  478.         return $this;
  479.     }
  481.     /**
  482.      * @return Collection<int, FlowUser>
  483.      */
  484.     public function getFlowUsers(): Collection
  485.     {
  486.         return $this->flowUsers;
  487.     }
  489.     public function addFlowUser(FlowUser $flowUser): self
  490.     {
  491.         if (!$this->flowUsers->contains($flowUser)) {
  492.             $this->flowUsers->add($flowUser);
  493.             $flowUser->setUser($this);
  494.         }
  496.         return $this;
  497.     }
  499.     public function removeFlowUser(FlowUser $flowUser): self
  500.     {
  501.         if ($this->flowUsers->removeElement($flowUser)) {
  502.             // set the owning side to null (unless already changed)
  503.             if ($flowUser->getUser() === $this) {
  504.                 $flowUser->setUser(null);
  505.             }
  506.         }
  508.         return $this;
  509.     }
  511.     public function isPaymentQuota(): ?bool
  512.     {
  513.         return $this->paymentQuota;
  514.     }
  516.     public function setPaymentQuota(bool $paymentQuota): self
  517.     {
  518.         $this->paymentQuota = $paymentQuota;
  520.         return $this;
  521.     }
  523.     public function getPercentQuota(): ?float
  524.     {
  525.         return $this->percentQuota;
  526.     }
  528.     public function setPercentQuota(?float $percentQuota): self
  529.     {
  530.         $this->percentQuota = $percentQuota;
  532.         return $this;
  533.     }
  535.     public function __toString(): string
  536.     {
  537.         return $this->getFullname();
  538.     }
  540.     public function getFunction(): ?Role
  541.     {
  542.         return $this->function;
  543.     }
  545.     public function setFunction(?Role $function): static
  546.     {
  547.         $this->function = $function;
  549.         return $this;
  550.     }
  552.     /**
  553.      * @return Collection<int, Document>
  554.      */
  555.     public function getDocuments(): Collection
  556.     {
  557.         return $this->documents;
  558.     }
  560.     public function addDocument(Document $document): static
  561.     {
  562.         if (!$this->documents->contains($document)) {
  563.             $this->documents->add($document);
  564.             $document->setEmployee($this);
  565.         }
  567.         return $this;
  568.     }
  570.     public function removeDocument(Document $document): static
  571.     {
  572.         if ($this->documents->removeElement($document)) {
  573.             // set the owning side to null (unless already changed)
  574.             if ($document->getEmployee() === $this) {
  575.                 $document->setEmployee(null);
  576.             }
  577.         }
  579.         return $this;
  580.     }
  582.     public function getContract(): ?Contract
  583.     {
  584.         return $this->contract;
  585.     }
  587.     public function setContract(?Contract $contract): static
  588.     {
  589.         $this->contract = $contract;
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection<int, EmployeeContract>
  596.      */
  597.     public function getContracts(): Collection
  598.     {
  599.         return $this->contracts;
  600.     }
  602.     public function addContract(EmployeeContract $contract): static
  603.     {
  604.         if (!$this->contracts->contains($contract)) {
  605.             $this->contracts->add($contract);
  606.             $contract->setEmployee($this);
  607.         }
  609.         return $this;
  610.     }
  612.     public function removeContract(EmployeeContract $contract): static
  613.     {
  614.         if ($this->contracts->removeElement($contract)) {
  615.             // set the owning side to null (unless already changed)
  616.             if ($contract->getEmployee() === $this) {
  617.                 $contract->setEmployee(null);
  618.             }
  619.         }
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return Collection<int, Address>
  626.      */
  627.     public function getAddresses(): Collection
  628.     {
  629.         return $this->addresses;
  630.     }
  632.     public function addAddress(Address $address): static
  633.     {
  634.         if (!$this->addresses->contains($address)) {
  635.             $this->addresses->add($address);
  636.             $address->setEmployee($this);
  637.         }
  639.         return $this;
  640.     }
  642.     public function removeAddress(Address $address): static
  643.     {
  644.         if ($this->addresses->removeElement($address)) {
  645.             // set the owning side to null (unless already changed)
  646.             if ($address->getEmployee() === $this) {
  647.                 $address->setEmployee(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * @return Collection<int, Card>
  656.      */
  657.     public function getCards(): Collection
  658.     {
  659.         return $this->cards;
  660.     }
  662.     public function addCard(Card $card): static
  663.     {
  664.         if (!$this->cards->contains($card)) {
  665.             $this->cards->add($card);
  666.             $card->setEmployee($this);
  667.         }
  669.         return $this;
  670.     }
  672.     public function removeCard(Card $card): static
  673.     {
  674.         if ($this->cards->removeElement($card)) {
  675.             // set the owning side to null (unless already changed)
  676.             if ($card->getEmployee() === $this) {
  677.                 $card->setEmployee(null);
  678.             }
  679.         }
  681.         return $this;
  682.     }
  684.     /**
  685.      * @return Collection<int, Mutuality>
  686.      */
  687.     public function getMutualities(): Collection
  688.     {
  689.         return $this->mutualities;
  690.     }
  692.     public function addMutuality(Mutuality $mutuality): static
  693.     {
  694.         if (!$this->mutualities->contains($mutuality)) {
  695.             $this->mutualities->add($mutuality);
  696.             $mutuality->setEmployee($this);
  697.         }
  699.         return $this;
  700.     }
  702.     public function removeMutuality(Mutuality $mutuality): static
  703.     {
  704.         if ($this->mutualities->removeElement($mutuality)) {
  705.             // set the owning side to null (unless already changed)
  706.             if ($mutuality->getEmployee() === $this) {
  707.                 $mutuality->setEmployee(null);
  708.             }
  709.         }
  711.         return $this;
  712.     }
  713. }