src/Entity/Event.php line 62

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Validator as CustomAssert;
  6. use ApiPlatform\Core\Annotation\ApiFilter;
  7. use ApiPlatform\Core\Annotation\ApiProperty;
  8. use ApiPlatform\Core\Annotation\ApiResource;
  9. use ApiPlatform\Core\Annotation\ApiSubresource;
  10. use ApiPlatform\Core\Serializer\Filter\PropertyFilter;
  11. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\DateFilter;
  12. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  13. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  14. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\ExistsFilter;
  15. use App\Repository\EventRepository;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Common\Collections\Collection;
  18. use Doctrine\ORM\Mapping as ORM;
  19. use Gedmo\Mapping\Annotation as Gedmo;
  20. use Symfony\Component\Serializer\Annotation\Groups;
  21. use Symfony\Component\Validator\Constraints as Assert;
  23. /**
  24.  * @ApiResource(
  25.  *      normalizationContext={
  26.  *          "groups"={"event:read"}
  27.  *      },
  28.  *      denormalizationContext={
  29.  *          "groups"={"event:write"}
  30.  *      },
  31.  *      collectionOperations={
  32.  *          "get"={
  33.  *              "security"="is_granted('ROLE_USER')"
  34.  *          }
  35.  *     },
  36.  *     itemOperations={
  37.  *          "get"={
  38.  *              "security"="is_granted('ROLE_USER')"
  39.  *          }
  40.  *      }
  41.  * )
  42.  * @ApiFilter(DateFilter::class)
  43.  * @ApiFilter(SearchFilter::class, 
  44.  *      strategy="exact", 
  45.  *      properties={
  46.  *          "name":"partial", "status", "company", "isVirtual", "active",
  47.  *          "registrations.status", "registrations.client"
  48.  *      }
  49.  * )
  50.  * @ApiFilter(OrderFilter::class)
  51.  * @ApiFilter(ExistsFilter::class, properties={"parent"})
  52.  * @ApiFilter(PropertyFilter::class, 
  53.  *      arguments={
  54.  *          "parameterName"="fields", 
  55.  *          "overrideDefaultProperties"=true
  56.  *     }
  57.  * )
  58.  * @ORM\Entity(repositoryClass=EventRepository::class)
  59.  * 
  60.  * @CustomAssert\EventClass
  61.  */
  62. class Event
  63. {
  64.     const STATUS_OPEN = 'open'; // the event is open to acquire a specialist
  65.     const STATUS_PENDING_SPECIALIST = 'pending_specialist_validation'; // the event is open to acquire a specialist
  66.     const STATUS_VALID = 'valid'; // the event has a specialist
  67.     const STATUS_CANCELED = 'canceled'; // the event is canceled
  68.     const STATUS_FINISHED = 'finished'; // the event is finished
  69.     const STATUS_CANCELED_MAIL = 'canceled_mail'; // the event is canceled and send mails
  70.     const STATUS_FINISHED_MAIL = 'finished_mail'; // the event is finished and send mails
  72.     // CALENDAR TYPE
  73.     const  CALENDAR_TYPE_MONTHLY = "monthly";
  74.     const  CALENDAR_TYPE_WEEKLY = "weekly";
  75.     const  CALENDAR_TYPE_DAILY = "daily";
  77.     const CALENDAR_TYPES = [
  78.         self::CALENDAR_TYPE_MONTHLY,
  79.         self::CALENDAR_TYPE_WEEKLY,
  80.         self::CALENDAR_TYPE_DAILY,
  81.     ];
  83.     /**
  84.      * Available statuses for the event
  85.      */
  86.     const STATUSES = [
  87.         self::STATUS_OPEN,
  88.         self::STATUS_VALID,
  89.         self::STATUS_CANCELED,
  90.         self::STATUS_FINISHED,
  91.         self::STATUS_CANCELED_MAIL,
  92.         self::STATUS_FINISHED_MAIL,
  93.     ];
  95.     const STATUSES_CLOSED = [
  96.         self::STATUS_CANCELED,
  97.         self::STATUS_FINISHED,
  98.     ];
  100.     const STATUSES_MAILER = [
  101.         self::STATUS_CANCELED => self::STATUS_CANCELED_MAIL,
  102.         self::STATUS_FINISHED => self::STATUS_FINISHED_MAIL,
  103.     ];
  105.     /**
  106.      * @ORM\Id
  107.      * @ORM\GeneratedValue
  108.      * @ORM\Column(type="integer")
  109.      * @ApiProperty(identifier=true)
  110.      * @Groups({"event:read", "event:read:id", "registration:read"})
  111.      */
  112.     private $id;
  114.     /**
  115.      * @ORM\Column(type="string", length=255)
  116.      * @Groups({"event:read", "event:read:name", "event:write", "registration:read"})
  117.      * @Assert\NotBlank
  118.      */
  119.     private $name;
  121.     /**
  122.      * @ORM\Column(type="text")
  123.      * @Groups({"event:read", "event:read:description", "event:write", "registration:read"})
  124.      * @Assert\NotBlank
  125.      */
  126.     private $description;
  128.     /**
  129.      * @ORM\Column(type="integer")
  130.      * @Groups({"event:read", "event:read:duration", "event:write", "registration:read"})
  131.      * @Assert\NotBlank
  132.      */
  133.     private $duration;
  135.     /**
  136.      * @ORM\Column(type="integer")
  137.      * @Groups({"event:read", "event:read:capacity", "event:write", "registration:read"})
  138.      * @Assert\NotBlank
  139.      */
  140.     private $capacity;
  142.     /**
  143.      * @ORM\Column(type="float")
  144.      * @Groups({"event:read", "event:read:price", "event:write", "registration:read"})
  145.      */
  146.     private $price = 0;
  148.     /**
  149.      * @ORM\Column(type="datetime")
  150.      * @Groups({"event:read", "event:read:start", "event:write", "registration:read"})
  151.      * @Assert\NotBlank
  152.      */
  153.     private $start;
  155.     /**
  156.      * @ORM\Column(type="datetime")
  157.      * @Groups({"event:read", "event:read:end", "event:write", "registration:read"})
  158.      * @Assert\NotBlank
  159.      */
  160.     private $end;
  162.     /**
  163.      * @ORM\Column(type="float", nullable=true)
  164.      * @Groups({"event:read", "event:read:sellingPrice", "event:write", "registration:read"})
  165.      */
  166.     private $sellingPrice;
  168.     /**
  169.      * @ORM\Column(type="float", nullable=true)
  170.      * @Groups({"event:read", "event:read:purchasePrice", "event:write"})
  171.      */
  172.     private $purchasePrice;
  174.     /**
  175.      * @ORM\Column(type="float", nullable=true)
  176.      * @Groups({"event:read", "event:read:tva", "event:write"})
  177.      */
  178.     private $tva;
  180.     /**
  181.      * @ORM\Column(type="datetime")
  182.      * @Gedmo\Timestampable(on="create")
  183.      * @Groups({"event:read", "event:read:createdAt", "event:write"})
  184.      */
  185.     private $createdAt;
  187.     /**
  188.      * @ORM\Column(type="datetime", options={"default": "CURRENT_TIMESTAMP"})
  189.      * @Gedmo\Timestampable(on="update")
  190.      * @Groups({"event:read", "event:read:updatedAt", "event:write"})
  191.      */
  192.     private $updatedAt;
  194.     /**
  195.      * @ORM\ManyToOne(targetEntity=Event::class, inversedBy="children")
  196.      * @Groups({"event:read", "event:read:parent", "event:write"})
  197.      */
  198.     private $parent;
  200.     /**
  201.      * @ORM\OneToMany(targetEntity=Event::class, mappedBy="parent", cascade={"all"})
  202.      * @Groups({"event:read", "event:read:children", "event:write"})
  203.      */
  204.     private $children;
  206.     /**
  207.      * @ORM\ManyToOne(targetEntity=Workshop::class, inversedBy="events")
  208.      * @ORM\JoinColumn(nullable=false)
  209.      * @Groups({"event:read", "event:read:workshop", "event:write"})
  210.      * @Assert\NotBlank
  211.      */
  212.     private $workshop;
  214.     /**
  215.      * @ORM\ManyToOne(targetEntity=Room::class, inversedBy="events", cascade={"persist"})
  216.      * @Groups({"event:read", "event:read:room", "event:write", "registration:read"})
  217.      */
  218.     private $room;
  220.     /**
  221.      * @ORM\ManyToOne(targetEntity=Specialist::class, inversedBy="events")
  222.      * @Groups({"event:read", "event:read:specialist", "event:write"})
  223.      */
  224.     private $specialist;
  226.     /**
  227.      * @var Collection|Registration[]
  228.      * @ORM\OneToMany(targetEntity=Registration::class, mappedBy="event", orphanRemoval=true)
  229.      * @Groups({"event:read", "event:read:registrations", "event:write"})
  230.      */
  231.     private $registrations;
  233.     /**
  234.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="events")
  235.      * @Groups({"event:read", "event:read:company", "event:write"})
  236.      */
  237.     private $company;
  239.     /**
  240.      * @ORM\Column(type="boolean", options={"default": "1"})
  241.      * @Groups({"event:read", "event:read:active", "event:write", "registration:read"})
  242.      */
  243.     private $active = true;
  245.     /**
  246.      * @ORM\Column(type="string", length=255)
  247.      * @Groups({"event:read", "event:read:color", "event:write"})
  248.      */
  249.     private $color;
  251.     /**
  252.      * @ORM\OneToMany(targetEntity=SpecialistEventApplication::class, mappedBy="event", orphanRemoval=true)
  253.      * @Groups({"event:read", "event:read:applications", "event:write"})
  254.      */
  255.     private $applications;
  257.     /**
  258.      * @ORM\Column(type="string", length=50)
  259.      * @Groups({"event:read", "event:read:status", "event:write", "registration:read"})
  260.      * @Assert\Choice(choices=self::STATUSES)
  261.      */
  262.     private $status = self::STATUS_OPEN;
  264.     /**
  265.      * If the event is locked it means that a company cannot modify the event
  266.      *
  267.      * @ORM\Column(type="boolean", options={"default": "0"})
  268.      * @Groups({"event:read", "event:read:locked", "event:write"})
  269.      */
  270.     private $locked = false;
  272.     /**
  273.      * @ORM\OneToOne(targetEntity=CancellationParameters::class, mappedBy="event", cascade={"persist", "remove"})
  274.      * @Groups({"event:read", "event:read:cancellationParameters", "event:write"})
  275.      */
  276.     private $cancellationParameters;
  278.     /**
  279.      * @ORM\Column(type="string", length=255, nullable=true)
  280.      * @Groups({"event:read", "event:read:formLink", "event:write", "registration:read"})
  281.      */
  282.     private $formLink;
  284.     /**
  285.      * @ORM\Column(type="string", length=255, nullable=true)
  286.      * @Groups({"event:read", "event:read:statusMail", "event:write"})
  287.      */
  288.     private $statusMail;
  290.     /**
  291.      * @ORM\Column(type="array", nullable=true)
  292.      */
  293.     private $statusLogs = [];
  295.     /**
  296.      * @ORM\OneToMany(targetEntity=CancelEventApplication::class, mappedBy="event", orphanRemoval=true)
  297.      * @Groups({"event:read", "event:read:cancelEventApplications", "event:write"})
  298.      */
  299.     private $cancelEventApplications;
  301.     /**
  302.      * Will be filled with a unique id if repeated
  303.      * @var string
  304.      * @Groups({"event:read", "event:read:repeated"})
  305.      */
  306.     private $repeated = null;
  308.     /**
  309.      * @ORM\Column(type="boolean", options={"default": 0})
  310.      * @Groups({"event:read", "event:read:isVirtual", "event:write", "registration:read"})
  311.      */
  312.     private $isVirtual = false;
  314.     /**
  315.      * @ORM\Column(type="string", length=255, nullable=true)
  316.      * @Groups({"event:read", "event:read:virtualUrl", "event:write", "registration:read"})
  317.      */
  318.     private $virtualUrl;
  320.     /**
  321.      * @ORM\Column(type="boolean", nullable=true)
  322.      * @Groups({"event:read", "event:read:isSpecialistTva", "event:write"})
  323.      */
  324.     private $isSpecialistTva;
  326.     /**
  327.      * @ORM\Column(type="string", length=255, nullable=true)
  328.      * @Groups({"event:read", "event:read:updatedBy"})
  329.      */
  330.     private $updatedBy;
  332.     /**
  333.      * @ORM\Column(type="float", nullable=true)
  334.      * @Groups({"event:read", "event:read:coefMajoration", "event:write"})
  335.      */
  336.     private $coefMajoration;
  338.     /**
  339.      * @ORM\Column(type="float", nullable=true)
  340.      * @Groups({"event:read", "event:read:specialistPrice", "event:write"})
  341.      */
  342.     private $specialistPrice;
  344.     /**
  345.      * @ORM\Column(type="float", nullable=true)
  346.      * @Groups({"event:read", "event:read:coefMargin", "event:write"})
  347.      */
  348.     private $coefMargin;
  350.     /**
  351.      * @ORM\OneToMany(targetEntity=AffiliatedEventApplication::class, mappedBy="event", orphanRemoval=true)
  352.      * @Groups({"event:read", "event:read:affiliatedEventApplications", "event:write"})
  353.      */
  354.     private $affiliatedEventApplications;
  356.     /**
  357.      * @ORM\OneToOne(targetEntity=MarketplaceReservation::class, mappedBy="event", cascade={"persist", "remove"})
  358.      * @Groups({"event:read", "event:read:marketplaceReservation"})
  359.      */
  360.     private $marketplaceReservation;
  362.     /**
  363.      * @ORM\Column(type="boolean", options={"default": 0})
  364.      * @Groups({"event:read", "event:read:isMarketplace", "event:write", "registration:read"})
  365.      */
  366.     private $isMarketplace = false;
  368.     /**
  369.      * @ORM\Column(type="boolean", options={"default": 0})
  370.      * @Groups({"event:read", "event:read:isFromStats", "event:write", "registration:read"})
  371.      */
  372.     private $isFromStats = false;
  374.     /**
  375.      * @ORM\Column(type="text", nullable=true)
  376.      * @Groups({"event:read", "event:read:callsheetComment", "event:write"})
  377.      */
  378.     private $callsheetComment;
  380.     /**
  381.      * @ORM\Column(type="boolean", options={"default": 0})
  382.      * @Groups({"event:read", "event:read:overQuota", "event:write"})
  383.      */
  384.     private $overQuota = false;
  386.     /**
  387.      * @ORM\Column(type="string", length=255, nullable=true)
  388.      * @Groups({"event:read", "event:read:overQuotaInfo", "event:write"})
  389.      */
  390.     private $overQuotaInfo;
  392.     /**
  393.      * @ORM\Column(type="boolean", options={"default": 0})
  394.      * @Groups({"event:read", "event:read:waitingListAssignationAuto", "event:write"})
  395.      */
  396.     private $waitingListAssignationAuto = false;
  398.     /**
  399.      * @ORM\Column(type="boolean", nullable=true, options={"default": 0})
  400.      * @Groups({"event:read", "event:read:waitingListDefault", "event:write"})
  401.      */
  402.     private $waitingListDefault = false;
  404.     /**
  405.      * @ORM\ManyToMany(targetEntity=Segmentation::class, inversedBy="events")
  406.      * @Groups({"event:read", "event:read:segmentations", "event:write"})
  407.      */
  408.     private $segmentations;
  410.     /**
  411.      * @ORM\Column(type="boolean", options={"default": 0})
  412.      * @Groups({"event:read", "event:read:negativeMailSent", "event:write"})
  413.      */
  414.     private $negativeMailSent = false;
  416.     /**
  417.      * Inscriptions disponibles restantes
  418.      * @Groups({"event:read", "event:read:remainingAvailableRegistrations", "event:write"})
  419.      */
  420.     private $remainingAvailableRegistrations = null;
  422.     /**
  423.      * @Groups({"event:read", "event:read:isRegistered"})
  424.      * @var ?bool
  425.      */
  426.     public $isRegistered = null;
  428.     public $sendNotification = false;
  430.     /**
  431.      * @Groups({"event:read", "event:read:imageUrl"})
  432.      * @var ?string
  433.      */
  434.     private $imageUrl = null;
  436.     public function __construct()
  437.     {
  438.         $this->children = new ArrayCollection();
  439.         $this->registrations = new ArrayCollection();
  440.         $this->applications = new ArrayCollection();
  441.         $this->createdAt = new \DateTime();
  442.         $this->updatedAt = new \DateTime();
  443.         $this->statusLogs = [];
  444.         $this->cancelEventApplications = new ArrayCollection();
  445.         $this->affiliatedEventApplications = new ArrayCollection();
  446.         $this->segmentations = new ArrayCollection();
  447.     }
  449.     public function getId(): ?int
  450.     {
  451.         return $this->id;
  452.     }
  454.     public function getName(): ?string
  455.     {
  456.         return $this->name;
  457.     }
  459.     public function setName(string $name): self
  460.     {
  461.         $this->name = $name;
  463.         return $this;
  464.     }
  466.     public function getDescription(): ?string
  467.     {
  468.         return $this->description;
  469.     }
  471.     public function setDescription(string $description): self
  472.     {
  473.         $this->description = $description;
  475.         return $this;
  476.     }
  478.     public function getDuration(): ?int
  479.     {
  480.         return $this->duration;
  481.     }
  483.     public function setDuration(int $duration): self
  484.     {
  485.         $this->duration = $duration;
  487.         return $this;
  488.     }
  490.     public function getCapacity(): ?int
  491.     {
  492.         return $this->capacity;
  493.     }
  495.     public function setCapacity(int $capacity): self
  496.     {
  497.         $this->capacity = $capacity;
  499.         return $this;
  500.     }
  502.     public function getPrice(): ?float
  503.     {
  504.         return $this->price;
  505.     }
  507.     public function setPrice(?float $price): self
  508.     {
  509.         $this->price = floatval($price);
  511.         return $this;
  512.     }
  514.     public function getStart(): ?\DateTime
  515.     {
  516.         return $this->start;
  517.     }
  519.     public function setStart(\DateTime $start): self
  520.     {
  521.         $this->start = $start;
  523.         return $this;
  524.     }
  526.     public function getEnd(): ?\DateTime
  527.     {
  528.         return $this->end;
  529.     }
  531.     public function setEnd(\DateTime $end): self
  532.     {
  533.         $this->end = $end;
  535.         return $this;
  536.     }
  538.     public function getCreatedAt(): ?\DateTime
  539.     {
  540.         return $this->createdAt;
  541.     }
  543.     public function setCreatedAt(\DateTime $createdAt): self
  544.     {
  545.         $this->createdAt = $createdAt;
  547.         return $this;
  548.     }
  550.     public function getParent(): ?self
  551.     {
  552.         return $this->parent;
  553.     }
  555.     public function setParent(?self $parent): self
  556.     {
  557.         $this->parent = $parent;
  559.         return $this;
  560.     }
  562.     /**
  563.      * @return Collection|self[]
  564.      */
  565.     public function getChildren(): Collection
  566.     {
  567.         return $this->children;
  568.     }
  570.     public function addChild(self $child): self
  571.     {
  572.         if (!$this->children->contains($child)) {
  573.             $this->children[] = $child;
  574.             $child->setParent($this);
  575.         }
  577.         return $this;
  578.     }
  580.     public function removeChild(self $child): self
  581.     {
  582.         if ($this->children->removeElement($child)) {
  583.             // set the owning side to null (unless already changed)
  584.             if ($child->getParent() === $this) {
  585.                 $child->setParent(null);
  586.             }
  587.         }
  589.         return $this;
  590.     }
  592.     public function getWorkshop(): ?Workshop
  593.     {
  594.         return $this->workshop;
  595.     }
  597.     public function setWorkshop(?Workshop $workshop): self
  598.     {
  599.         $this->workshop = $workshop;
  600.         if (empty($this->color)) {
  601.             $this->color = $workshop->getColor();
  602.         }
  603.         return $this;
  604.     }
  606.     public function getRoom(): ?Room
  607.     {
  608.         return $this->room;
  609.     }
  611.     public function setRoom(?Room $room): self
  612.     {
  613.         $this->room = $room;
  614.         $this->setCompany($this->room->getCompany());
  615.         return $this;
  616.     }
  618.     public function getSpecialist(): ?Specialist
  619.     {
  620.         return $this->specialist;
  621.     }
  623.     public function setSpecialist(?Specialist $specialist): self
  624.     {
  625.         $this->specialist = $specialist;
  627.         return $this;
  628.     }
  630.     /**
  631.      * @return Collection|Registration[]
  632.      */
  633.     public function getRegistrations(): Collection
  634.     {
  635.         return $this->registrations;
  636.     }
  638.     public function addRegistration(Registration $registration): self
  639.     {
  640.         if (!$this->registrations->contains($registration)) {
  641.             $this->registrations[] = $registration;
  642.             $registration->setEvent($this);
  643.         }
  645.         return $this;
  646.     }
  648.     public function removeRegistration(Registration $registration): self
  649.     {
  650.         if ($this->registrations->removeElement($registration)) {
  651.             // set the owning side to null (unless already changed)
  652.             if ($registration->getEvent() === $this) {
  653.                 $registration->setEvent(null);
  654.             }
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * Permet de récupérer la derniere Registration d'un Client
  662.      * @var Client $client
  663.      * @return Registration|null
  664.      */
  665.     public function getLastClientRegistration(Client $client): ?Registration
  666.     {
  667.         $lastClientRegistration = null;
  668.         if(!empty($this->registrations)) {
  669.             foreach($this->registrations as $registration) {
  670.                 if($registration->getClient() instanceof Client && $registration->getClient()->getId() === $client->getId() 
  671.                     && (empty($lastClientRegistration) || $registration->getCreatedAt() > $lastClientRegistration->getCreatedAt())) {
  672.                     $lastClientRegistration = $registration;
  673.                 }
  674.             };
  675.         }
  677.         return $lastClientRegistration;
  678.     }
  680.     /**
  681.      * @param ArrayCollection $children
  682.      * @return Event
  683.      */
  684.     public function setChildren(ArrayCollection $children): Event
  685.     {
  686.         $this->children = $children;
  687.         return $this;
  688.     }
  690.     public function getCompany(): ?Company
  691.     {
  692.         return $this->company;
  693.     }
  695.     public function setCompany(?Company $company): self
  696.     {
  697.         $this->company = $company;
  699.         return $this;
  700.     }
  702.     public function getActive(): ?bool
  703.     {
  704.         return $this->active;
  705.     }
  707.     public function setActive(bool $active): self
  708.     {
  709.         $this->active = $active;
  711.         return $this;
  712.     }
  714.     public function getColor(): ?string
  715.     {
  716.         return $this->color;
  717.     }
  719.     public function setColor(?string $color): self
  720.     {
  721.         if (!empty($color)) {
  722.             $this->color = $color;
  723.         }
  725.         return $this;
  726.     }
  728.     /**
  729.      * @return Collection|SpecialistEventApplication[]
  730.      */
  731.     public function getApplications(): Collection
  732.     {
  733.         return $this->applications;
  734.     }
  736.     public function addApplication(SpecialistEventApplication $application): self
  737.     {
  738.         if (!$this->applications->contains($application)) {
  739.             $this->applications[] = $application;
  740.             $application->setEvent($this);
  741.         }
  743.         return $this;
  744.     }
  746.     public function removeApplication(SpecialistEventApplication $application): self
  747.     {
  748.         if ($this->applications->removeElement($application)) {
  749.             // set the owning side to null (unless already changed)
  750.             if ($application->getEvent() === $this) {
  751.                 $application->setEvent(null);
  752.             }
  753.         }
  755.         return $this;
  756.     }
  758.     public function getStatus(): ?string
  759.     {
  760.         return $this->status;
  761.     }
  763.     public function setStatus(string $status): self
  764.     {
  765.         $this->status = $status;
  767.         return $this;
  768.     }
  770.     public function getCellColor(): string
  771.     {
  772.         $now = new \DateTime("now", new \DateTimeZone("Europe/Paris"));
  773.         if ($now <= $this->end && $now >= $this->start) {
  774.             $result = 'success';
  775.         } elseif ($now >= $this->start) {
  776.             $result = 'danger';
  777.         } else {
  778.             $result = 'default';
  779.         }
  780.         return $result;
  781.     }
  783.     public function getLocked(): ?bool
  784.     {
  785.         return $this->locked;
  786.     }
  788.     public function setLocked(bool $locked): self
  789.     {
  790.         $this->locked = $locked;
  792.         return $this;
  793.     }
  795.     public function getSellingPrice(): ?float
  796.     {
  797.         return $this->sellingPrice;
  798.     }
  800.     public function setSellingPrice(?float $sellingPrice): self
  801.     {
  802.         $this->sellingPrice = $sellingPrice;
  804.         return $this;
  805.     }
  807.     public function getPurchasePrice(): ?float
  808.     {
  809.         return $this->purchasePrice;
  810.     }
  812.     public function setPurchasePrice(?float $purchasePrice): self
  813.     {
  814.         $this->purchasePrice = $purchasePrice;
  816.         return $this;
  817.     }
  819.     public function getTva(): ?float
  820.     {
  821.         return $this->tva;
  822.     }
  824.     public function setTva(?float $tva): self
  825.     {
  826.         $this->tva = $tva;
  828.         return $this;
  829.     }
  831.     public function getUpdatedAt(): ?\DateTimeInterface
  832.     {
  833.         return $this->updatedAt;
  834.     }
  836.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  837.     {
  838.         $this->updatedAt = $updatedAt;
  840.         return $this;
  841.     }
  843.     public function getCancellationParameters(): ?CancellationParameters
  844.     {
  845.         return $this->cancellationParameters;
  846.     }
  848.     public function setCancellationParameters(?CancellationParameters $cancellationParameters): self
  849.     {
  850.         // unset the owning side of the relation if necessary
  851.         if ($cancellationParameters === null && $this->cancellationParameters !== null) {
  852.             $this->cancellationParameters->setEvent(null);
  853.         }
  855.         // set the owning side of the relation if necessary
  856.         if ($cancellationParameters !== null && $cancellationParameters->getEvent() !== $this) {
  857.             $cancellationParameters->setEvent($this);
  858.         }
  860.         $this->cancellationParameters = $cancellationParameters;
  862.         return $this;
  863.     }
  865.     public function getFormLink(): ?string
  866.     {
  867.         return $this->formLink;
  868.     }
  870.     public function setFormLink(string $formLink): self
  871.     {
  872.         $this->formLink = $formLink;
  874.         return $this;
  875.     }
  877.     /**
  878.      * Get valid registered participants count
  879.      * @return int
  880.      */
  881.     public function getRegisteredCount(): int
  882.     {
  883.         $cnt = 0;
  884.         foreach ($this->registrations as $registration) {
  885.             if ($registration->isRegistered()) $cnt++;
  886.         }
  888.         return $cnt;
  889.     }
  891.     /**
  892.      * Get valid registered participants
  893.      * @return array
  894.      */
  895.     public function getRegistered(): array
  896.     {
  897.         $registered = [];
  898.         foreach ($this->registrations as $registration) {
  899.             if ($registration->isRegistered()) $registered[] = $registration;
  900.         }
  902.         return $registered;
  903.     }
  905.     public function getStatusMail(): ?string
  906.     {
  907.         return $this->statusMail;
  908.     }
  910.     public function setStatusMail(?string $statusMail): self
  911.     {
  912.         $this->statusMail = $statusMail;
  914.         return $this;
  915.     }
  917.     public function getStatusLogs(): ?array
  918.     {
  919.         return $this->statusLogs;
  920.     }
  922.     public function setStatusLogs(?array $statusLogs): self
  923.     {
  924.         $this->statusLogs = $statusLogs;
  926.         return $this;
  927.     }
  929.     /**
  930.      * @return Collection<int, CancelEventApplication>
  931.      */
  932.     public function getCancelEventApplications(): Collection
  933.     {
  934.         return $this->cancelEventApplications;
  935.     }
  937.     public function addCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  938.     {
  939.         if (!$this->cancelEventApplications->contains($cancelEventApplication)) {
  940.             $this->cancelEventApplications[] = $cancelEventApplication;
  941.             $cancelEventApplication->setEvent($this);
  942.         }
  944.         return $this;
  945.     }
  947.     public function removeCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  948.     {
  949.         if ($this->cancelEventApplications->removeElement($cancelEventApplication)) {
  950.             // set the owning side to null (unless already changed)
  951.             if ($cancelEventApplication->getEvent() === $this) {
  952.                 $cancelEventApplication->setEvent(null);
  953.             }
  954.         }
  956.         return $this;
  957.     }
  958.     
  959.     /**
  960.      * Estime le prix d'achat de l'event en fonction un Specialist
  961.      */
  962.     public function getEstimatedPurchasePrice($specialist): ?int
  963.     {
  964.         $estimatedPrice = null;
  965.         // Récupérer la catégorie de l'event
  966.         $tag = ($this->workshop->getTag() instanceof Tag) ? $this->workshop->getTag() : null;
  968.         if($specialist instanceof Specialist) {
  969.             $specialistTags = $specialist->getSpecialistTags()->toArray() ?? [];
  970.             foreach ($specialistTags as $specialistTag) {
  971.                 if($specialistTag instanceof SpecialistTag && $specialistTag->getTag() instanceof Tag
  972.                     && $specialistTag->getTag()->getId() == $tag->getId()) {
  973.                     $estimatedPrice = $specialistTag->getPrice();
  974.                     break;
  975.                 }
  976.             }
  977.         }
  978.         return $estimatedPrice;
  979.     }
  981.     /**
  982.      * Estime le prix de vente de l'Event en fonction d'un Company
  983.      */
  984.     public function getEstimatedSellingPrice($company): ?int
  985.     {
  986.         $estimatedPrice = null;
  988.         if($company instanceof Company) {
  990.         }
  991.         return $estimatedPrice;
  992.     }
  994.     /**
  995.      * @param string|null $repeated
  996.      * @return Event
  997.      */
  998.     public function setRepeated(?string $repeated): Event
  999.     {
  1000.         $this->repeated = $repeated;
  1001.         return $this;
  1002.     }
  1004.     /**
  1005.      * @return string
  1006.      */
  1007.     public function getRepeated(): ?string
  1008.     {
  1009.         return $this->repeated;
  1010.     }
  1012.     public function isEventRepeated(): bool
  1013.     {
  1014.         return !empty($this->repeated);
  1015.     }
  1016.     
  1017.     public function getIsVirtual(): ?bool
  1018.     {
  1019.         return $this->isVirtual;
  1020.     }
  1022.     public function setIsVirtual(bool $isVirtual): self
  1023.     {
  1024.         $this->isVirtual = $isVirtual;
  1026.         return $this;
  1027.     }
  1028.         
  1029.     public function getVirtualUrl(): ?string
  1030.     {
  1031.         return $this->virtualUrl;
  1032.     }
  1034.     public function setVirtualUrl(?string $virtualUrl): self
  1035.     {
  1036.         $this->virtualUrl = $virtualUrl;
  1038.         return $this;
  1039.     }
  1041.     public function getIsSpecialistTva(): ?bool
  1042.     {
  1043.         return $this->isSpecialistTva;
  1044.     }
  1046.     public function setIsSpecialistTva(?bool $isSpecialistTva): self
  1047.     {
  1048.         $this->isSpecialistTva = $isSpecialistTva;
  1050.         return $this;
  1051.     }
  1052.     
  1053.     public function getUpdatedBy(): ?string
  1054.     {
  1055.         return $this->updatedBy;
  1056.     }
  1058.     public function setUpdatedBy(?string $updatedBy): self
  1059.     {
  1060.         $this->updatedBy = $updatedBy;
  1061.         
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * Permet de savoir si l'Event est gratuit pour les participants
  1067.      * @return bool
  1068.      */
  1069.     public function isFree(): bool
  1070.     {
  1071.         return ($this->price > 0) ? false : true;
  1072.     }
  1074.     /**
  1075.      * Permet de savoir si l'Event est en cours
  1076.      * @return bool
  1077.      */
  1078.     public function isInProgress(): bool
  1079.     {
  1080.         $now = new \DateTime("now");
  1082.         return ($now <= $this->end && $now >= $this->start) ? true : false;
  1083.     }
  1085.     /**
  1086.      * Permet de savoir si l'Event est passé
  1087.      * @return bool
  1088.      */
  1089.     public function isPast(): bool
  1090.     {
  1091.         $now = new \DateTime("now");
  1093.         return ($now > $this->end) ? true : false;
  1094.     }
  1096.     /**
  1097.      * Permet de savoir si l'Event est en attente d'un Specialist
  1098.      * @return bool
  1099.      */
  1100.     public function isOpen(): bool
  1101.     {
  1102.         return ($this->status == $this::STATUS_OPEN) ? true : false;
  1103.     }
  1105.     /**
  1106.      * Permet de savoir si l'Event est a un Specialist
  1107.      * @return bool
  1108.      */
  1109.     public function isValid(): bool
  1110.     {
  1111.         return ($this->status == $this::STATUS_VALID) ? true : false;
  1112.     }
  1114.     /**
  1115.      * Permet de savoir si l'Event est annulé
  1116.      * @return bool
  1117.      */
  1118.     public function isCanceled(): bool
  1119.     {
  1120.         return ($this->status == $this::STATUS_CANCELED) ? true : false;
  1121.     }
  1123.     /**
  1124.      * Permet de savoir si une Demande d'annulation est en cours
  1125.      * @return bool
  1126.      */
  1127.     public function isCancelEventApplication(): bool
  1128.     {
  1129.         foreach($this->cancelEventApplications as $cancelEventApplication) {
  1130.             if($cancelEventApplication->getStatus() === CancelEventApplication::STATUS_OPEN) {
  1131.                 return true;
  1132.             }
  1133.         }
  1134.         return false;
  1135.     }
  1137.     /**
  1138.      * Permet de récupérer la demande d'annulation en cours
  1139.      * @return null|CancelEventApplication
  1140.      */
  1141.     public function cancelEventApplicationInProgress(): ?CancelEventApplication
  1142.     {
  1143.         foreach($this->cancelEventApplications as $cancelEventApplication) {
  1144.             if($cancelEventApplication->getStatus() === CancelEventApplication::STATUS_OPEN) {
  1145.                 return $cancelEventApplication;
  1146.             }
  1147.         }
  1148.         return null;
  1149.     }
  1151.     /**
  1152.      * Permet de récupérer la dernière demande d'annulation
  1153.      * @return null|CancelEventApplication
  1154.      */
  1155.     public function getLastCancelEventApplication(): ?CancelEventApplication
  1156.     {
  1157.         $lastCancelEventApplication = null;
  1158.         if (!empty($this->cancelEventApplications)) {
  1159.             $lastCancelEventApplication =  $this->cancelEventApplications[0];
  1160.             foreach($this->cancelEventApplications as $cancelEventApplication) {
  1161.                 if($cancelEventApplication->getId() > $lastCancelEventApplication->getId()) {
  1162.                     $lastCancelEventApplication = $cancelEventApplication;
  1163.                 }
  1164.             }
  1165.         }
  1166.         return $lastCancelEventApplication;
  1167.     }
  1169.     public function __toString()
  1170.     {
  1171.         return $this->getId() . " - " . $this->getName();
  1172.     }
  1173.     
  1174.     public function getNotation()
  1175.     {
  1176.         // Création variable ou l'on stock la note (default null) et création d'un compteur qui stockera le nombre de registrations valide
  1177.         $note = null;
  1178.         $regCount = 0;
  1179.         // Récup tableau des registrations
  1180.         $registrations = $this->getRegistrations()->toArray();
  1181.         // Parcourir le tableau pour valider ou non la présence
  1182.         // Si present récup workshopNote et ajouter dans la variable qui stock les notes et incrementer le compteur
  1183.         foreach ($registrations as $registration) {
  1184.             if ($registration->getWorkshopNote() != null) {
  1185.                 if ($note == null) {
  1186.                     $note = 0;
  1187.                 }
  1188.                 $note += $registration->getWorkshopNote();
  1189.                 $regCount ++; 
  1190.             }
  1191.         }
  1192.         // A la fin diviser la variable de note par le compteur si la note n'est pas null
  1193.         if ($note != null) {
  1194.             $note /= $regCount;
  1195.         }
  1196.        return $note;
  1197.     }
  1199.     public function getExpertNotation()
  1200.     {
  1201.          // Création variable ou l'on stock la note (default null) et création d'un compteur qui stockera le nombre de registrations valide
  1202.          $note = null;
  1203.          $regCount = 0;
  1204.          // Récup tableau des registrations
  1205.          $registrations = $this->getRegistrations()->toArray();
  1206.          // Parcourir le tableau pour valider ou non la présence
  1207.          // Si present récup expertNote et ajouter dans la variable qui stock les notes et incrementer le compteur
  1208.          foreach ($registrations as $registration) {
  1209.              if ($registration->getExpertNote() != null) {
  1210.                  if ($note == null) {
  1211.                      $note = 0;
  1212.                  }
  1213.                  $note += $registration->getExpertNote();
  1214.                  $regCount ++; 
  1215.              }
  1216.          }
  1217.          // A la fin diviser la variable de note par le compteur si la note n'est pas null
  1218.          if ($note != null) {
  1219.              $note /= $regCount;
  1220.          }
  1221.         return $note;
  1222.     }
  1224.     public function getNotationVoters()
  1225.     {
  1226.          // Création variable ou l'on stock la note (default null) et création d'un compteur qui stockera le nombre de registrations valide
  1227.          $regCount = 0;
  1228.          // Récup tableau des registrations
  1229.          $registrations = $this->getRegistrations()->toArray();
  1230.          // Parcourir le tableau pour valider ou non la présence
  1231.          // Si present récup expertNote et ajouter dans la variable qui stock les notes et incrementer le compteur
  1232.          foreach ($registrations as $registration) {
  1233.              if ($registration->getPresence() && $registration->getExpertNote() != null && $registration->getWorkshopNote() != null) {
  1234.                  $regCount ++; 
  1235.              }
  1236.          }
  1237.          // A la fin diviser la variable de note par le compteur si la note n'est pas null
  1238.         return $regCount;
  1239.     }
  1242.     public function getLimitDateCancellation(): ?\DateTime
  1243.     {
  1244.         if($this->getCancellationParameters() instanceof CancellationParameters) {
  1245.             return $this->getCancellationParameters()->getLimitDate();
  1246.         }
  1247.         return null;
  1248.     }
  1250.     /**
  1251.      * Permet de définir si l'event est en warning en fonction d'un certains nombre de jour donné 
  1252.      * et de ses parametres d'annulation
  1253.      * @var int $limitDays
  1254.      * @var int $limitHours
  1255.      */
  1256.     public function isWarning(int $limitDays = 0, int $limitHours = 0): bool
  1257.     {
  1258.         $minDate = (new \DateTime("now"))->setTime(0,0,1);
  1259.         $maxDate = (new \DateTime("now"))->setTime(23,59,59);
  1260.         if($limitDays > 0){
  1261.             $maxDate->modify("+ {$limitDays} days");
  1262.         }
  1263.         if($limitHours > 0){
  1264.             $maxDate->modify("+ {$limitHours} hours");
  1265.         }
  1267.         return (!$this->isPast() 
  1268.             && $this->getCancellationParameters() instanceof CancellationParameters
  1269.             && $this->getLimitDateCancellation() >=  $minDate 
  1270.             && $this->getLimitDateCancellation() <= $maxDate
  1271.             && $this->getRegisteredCount() <= $this->getCancellationParameters()->getMinCapacity() 
  1272.         );
  1273.     }
  1275.     public function getCoefMajoration(): ?float
  1276.     {
  1277.         return $this->coefMajoration;
  1278.     }
  1280.     public function setCoefMajoration(?float $coefMajoration): self
  1281.     {
  1282.         $this->coefMajoration = $coefMajoration;
  1284.         return $this;
  1285.     }
  1287.     public function getSpecialistPrice(): ?float
  1288.     {
  1289.         return $this->specialistPrice;
  1290.     }
  1292.     public function setSpecialistPrice(?float $specialistPrice): self
  1293.     {
  1294.         $this->specialistPrice = $specialistPrice;
  1296.         return $this;
  1297.     }
  1299.     public function getCoefMargin(): ?float
  1300.     {
  1301.         return $this->coefMargin;
  1302.     }
  1304.     public function setCoefMargin(?float $coefMargin): self
  1305.     {
  1306.         $this->coefMargin = $coefMargin;
  1308.         return $this;
  1309.     }
  1310.     
  1311.     /**
  1312.      * Permet de savoir si l'event est a venir
  1313.      */
  1314.     public function isInComing(): bool
  1315.     {
  1316.         return (!$this->isPast() && $this->status == self::STATUS_VALID);
  1317.     }
  1319.     /**
  1320.      * @return Collection<int, AffiliatedEventApplication>
  1321.      */
  1322.     public function getAffiliatedEventApplications(): Collection
  1323.     {
  1324.         return $this->affiliatedEventApplications;
  1325.     }
  1327.     public function addAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1328.     {
  1329.         if (!$this->affiliatedEventApplications->contains($affiliatedEventApplication)) {
  1330.             $this->affiliatedEventApplications[] = $affiliatedEventApplication;
  1331.             $affiliatedEventApplication->setEvent($this);
  1332.         }
  1334.         return $this;
  1335.     }
  1337.     public function removeAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1338.     {
  1339.         if ($this->affiliatedEventApplications->removeElement($affiliatedEventApplication)) {
  1340.             // set the owning side to null (unless already changed)
  1341.             if ($affiliatedEventApplication->getEvent() === $this) {
  1342.                 $affiliatedEventApplication->setEvent(null);
  1343.             }
  1344.         }
  1346.         return $this;
  1347.     }
  1349.     public function getMarketplaceReservation(): ?MarketplaceReservation
  1350.     {
  1351.         return $this->marketplaceReservation;
  1352.     }
  1354.     public function setMarketplaceReservation(?MarketplaceReservation $marketplaceReservation): self
  1355.     {
  1356.         // unset the owning side of the relation if necessary
  1357.         if ($marketplaceReservation === null && $this->marketplaceReservation !== null) {
  1358.             $this->marketplaceReservation->setEvent(null);
  1359.         }
  1361.         // set the owning side of the relation if necessary
  1362.         if ($marketplaceReservation !== null && $marketplaceReservation->getEvent() !== $this) {
  1363.             $marketplaceReservation->setEvent($this);
  1364.         }
  1366.         $this->marketplaceReservation = $marketplaceReservation;
  1368.         return $this;
  1369.     }
  1371.     public function getIsMarketplace(): ?bool
  1372.     {
  1373.         return $this->isMarketplace;
  1374.     }
  1376.     public function setIsMarketplace(bool $isMarketplace): self
  1377.     {
  1378.         $this->isMarketplace = $isMarketplace;
  1380.         return $this;
  1381.     }
  1383.     public function getIsFromStats(): ?bool
  1384.     {
  1385.         return $this->isFromStats;
  1386.     }
  1388.     public function setIsFromStats(bool $isFromStats): self
  1389.     {
  1390.         $this->isFromStats = $isFromStats;
  1392.         return $this;
  1393.     }
  1395.     public function getCallsheetComment(): ?string
  1396.     {
  1397.         return $this->callsheetComment;
  1398.     }
  1400.     public function setCallsheetComment(?string $callsheetComment): self
  1401.     {
  1402.         $this->callsheetComment = $callsheetComment;
  1404.         return $this;
  1405.     }
  1407.     public function getOverQuota(): ?bool
  1408.     {
  1409.         return $this->overQuota;
  1410.     }
  1412.     public function isOverQuota(): ?bool
  1413.     {
  1414.         return $this->overQuota;
  1415.     }
  1417.     public function setOverQuota(bool $overQuota): self
  1418.     {
  1419.         $this->overQuota = $overQuota;
  1421.         return $this;
  1422.     }
  1424.     public function getOverQuotaInfo(): ?string
  1425.     {
  1426.         return $this->overQuotaInfo;
  1427.     }
  1429.     public function setOverQuotaInfo(?string $overQuotaInfo): self
  1430.     {
  1431.         $this->overQuotaInfo = $overQuotaInfo;
  1433.         return $this;
  1434.     }
  1436.     /**
  1437.      * Permet de savoir si l'Event est complet (inscriptions)
  1438.      * @return bool
  1439.      */
  1440.     public function isFull(): bool
  1441.     {
  1442.         return ($this->getRegisteredCount() >= $this->getCapacity());
  1443.     }
  1445.     /**
  1446.      * Permet de savoir si l'Event est plus que complet (inscriptions)$
  1447.      * @return bool
  1448.      */
  1449.     public function isOverFull(): bool
  1450.     {
  1451.         return ($this->getRegisteredCount() > $this->getCapacity());
  1452.     }
  1454.     /**
  1455.      * Permet de récupérer les Registration sur liste d'attente
  1456.      * @return array
  1457.      */
  1458.     public function getWaitingList(): array
  1459.     {
  1460.         $waitingList = [];
  1462.         foreach($this->getRegistrations() as $registration) {
  1463.             if($registration->isOnWaitingList()) $waitingList[] = $registration;
  1464.         }
  1466.         return $waitingList;
  1467.     }
  1469.     /**
  1470.      * Compte le nombre de Registration de la liste d'attente
  1471.      * @return int
  1472.      */
  1473.     public function getWaitingListCount(): int
  1474.     {
  1475.         return count($this->getWaitingList());
  1476.     }
  1478.     public function getWaitingListAssignationAuto(): ?bool
  1479.     {
  1480.         return $this->waitingListAssignationAuto;
  1481.     }
  1483.     public function setWaitingListAssignationAuto(bool $waitingListAssignationAuto): self
  1484.     {
  1485.         $this->waitingListAssignationAuto = $waitingListAssignationAuto;
  1487.         return $this;
  1488.     }
  1490.     public function getWaitingListDefault(): ?bool
  1491.     {
  1492.         return $this->waitingListDefault;
  1493.     }
  1495.     public function setWaitingListDefault(?bool $waitingListDefault): self
  1496.     {
  1497.         $this->waitingListDefault = $waitingListDefault;
  1499.         return $this;
  1500.     }
  1502.     /**
  1503.      * Permet de savoir si c'est un parent
  1504.      */
  1505.     public function isParent(): bool
  1506.     {
  1507.         return (!$this->getChildren()->isEmpty());
  1508.     }
  1510.     /**
  1511.      * Permet de savoir si c'est un enfant
  1512.      */
  1513.     public function isChild(): bool
  1514.     {
  1515.         return ($this->getParent() instanceof Event);
  1516.     }
  1518.     /**
  1519.      * Permet de savoir si il contient des enfants
  1520.      */
  1521.     public function hasChildren(): bool
  1522.     {
  1523.         return (!$this->getChildren()->isEmpty());
  1524.     }
  1526.     /**
  1527.      * @return Collection<int, Segmentation>
  1528.      */
  1529.     public function getSegmentations(): Collection
  1530.     {
  1531.         return $this->segmentations;
  1532.     }
  1534.     public function addSegmentation(Segmentation $segmentation): self
  1535.     {
  1536.         if (!$this->segmentations->contains($segmentation)) {
  1537.             $this->segmentations[] = $segmentation;
  1538.         }
  1540.         return $this;
  1541.     }
  1543.     public function removeSegmentation(Segmentation $segmentation): self
  1544.     {
  1545.         $this->segmentations->removeElement($segmentation);
  1547.         return $this;
  1548.     }
  1550.     public function getNegativeMailSent(): ?bool
  1551.     {
  1552.         return $this->negativeMailSent;
  1553.     }
  1555.     public function setNegativeMailSent(bool $negativeMailSent): self
  1556.     {
  1557.         $this->negativeMailSent = $negativeMailSent;
  1559.         return $this;
  1560.     }
  1562.     public function getRemainingAvailableRegistrations(): ?int
  1563.     {
  1564.         $this->remainingAvailableRegistrations = $this->capacity - $this->getRegisteredCount();
  1566.         return abs($this->remainingAvailableRegistrations);
  1567.     }
  1569.     public function getImageUrl(): ?string
  1570.     {
  1571.         if($this->getWorkshop() instanceof Workshop) {
  1572.             $this->imageUrl = $this->getWorkshop()->getImageUrl();
  1573.         }
  1575.         return $this->imageUrl;
  1576.     }
  1578.     public function setImageUrl(string $imageUrl): self
  1579.     {
  1580.         $this->imageUrl = $imageUrl;
  1582.         return $this;
  1583.     }
  1584. }