src/Entity/Specialist.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\Address;
  6. use App\Repository\SpecialistRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\HttpFoundation\File\File;
  11. use Symfony\Component\Serializer\Annotation\Groups;
  12. use Symfony\Component\Serializer\Annotation\SerializedName;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Gedmo\Mapping\Annotation as Gedmo;
  17. /**
  18.  * @ORM\Entity(repositoryClass=SpecialistRepository::class)
  19.  * @Vich\Uploadable
  20.  * @ORM\HasLifecycleCallbacks()
  21.  */
  22. class Specialist
  23. {
  25.     const STATUS_WAITING_MAIL_CONFIRMATION = 'waiting_mail_confirmation'; // specialist has been created but must confirm by clicking on link in email
  26.     const STATUS_WAITING_ULTEAM_CONFIRMATION = 'waiting_ulteam_confirmation'; // specialist has validated mail but is waiting for ULTEAM to confirm registration
  27.     const STATUS_REFUSED = 'refused'; // specialist registration has been refused by ULTEAM
  28.     const STATUS_GRANTED = 'granted'; // specialist has been granted full access to his back office by ULTEAM
  29.     
  30.     /**
  31.      * Available statuses for the specialist
  32.      */
  33.     const STATUSES = [
  34.         self::STATUS_WAITING_MAIL_CONFIRMATION,
  35.         self::STATUS_WAITING_ULTEAM_CONFIRMATION,
  36.         self::STATUS_REFUSED,
  37.         self::STATUS_GRANTED,
  38.     ];
  40.     /**
  41.      * Available types for the specialist
  42.      */
  43.     const TYPES = [
  44.         100 => 'Indépendant',
  45.         200 => 'Affilié',
  46.         300 => '100% Affilié'
  47.     ];
  49.     use Address;
  51.     /**
  52.      * @ORM\Id
  53.      * @ORM\GeneratedValue
  54.      * @ORM\Column(type="integer")
  55.      * @Groups({"search", "event:read"})
  56.      */
  57.     private $id;
  59.     /**
  60.      * @ORM\Column(type="string", length=255)
  61.      * @Groups({"event:read"})
  62.      * @Assert\NotBlank
  63.      */
  64.     private $firstName;
  66.     /**
  67.      * @ORM\Column(type="string", length=255)
  68.      * @Groups({"event:read"})
  69.      * @Assert\NotBlank
  70.      */
  71.     private $lastName;
  73.     /**
  74.      * @ORM\Column(type="datetime")
  75.      * @Gedmo\Timestampable(on="create")
  76.      * @var \DateTime
  77.      */
  78.     private $createdAt;
  80.     /**
  81.      * @ORM\Column(type="string", length=255, nullable=true)
  82.      * @Groups({"event:read"})
  83.      */
  84.     private $image;
  86.     /**
  87.      * @Groups({"specialist:read", "specialist:read:imageUrl", "event:read"})
  88.      * @var ?string
  89.      */
  90.     private $imageUrl = "https://placehold.co/600x300";
  92.     /**
  93.      * @Vich\UploadableField(mapping="specialists_images", fileNameProperty="image")
  94.      * @Assert\File(
  95.      *     mimeTypes={"image/jpeg", "image/gif", "image/png"},
  96.      *     maxSize="700Ki",
  97.      * )
  98.      * @var File|null
  99.      */
  100.     private $imageFile;
  102.     /**
  103.      * @ORM\OneToOne(targetEntity=User::class, inversedBy="specialist", cascade={"persist", "remove"})
  104.      * @ORM\JoinColumn(nullable=false)
  105.      * @Assert\Valid
  106.      */
  107.     private $user;
  109.     /**
  110.      * @ORM\Column(type="datetime", nullable=true)
  111.      * @Gedmo\Timestampable(on="update")
  112.      */
  113.     private $updatedAt;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=SpecialistTag::class, mappedBy="specialist", cascade={"all"})
  117.      * @Groups({"event:read"})
  118.      */
  119.     private $specialistTags;
  121.     /**
  122.      * @ORM\OneToMany(targetEntity=Event::class, mappedBy="specialist")
  123.      */
  124.     private $events;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=SpecialistEventApplication::class, mappedBy="specialist", orphanRemoval=true)
  128.      */
  129.     private $applications;
  131.     /**
  132.      * Search radius in meters
  133.      * @ORM\Column(type="float")
  134.      */
  135.     private $radius = 5;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity=Workshop::class, mappedBy="specialist")
  139.      */
  140.     private $workshops;
  142.     /**
  143.      * @ORM\Column(type="text", nullable=true)
  144.      * @Groups({"event:read"})
  145.      */
  146.     private $description;
  148.     /**
  149.      * @ORM\Column(type="string", length=255, nullable=true)
  150.      * @Assert\Length(max="12", maxMessage="Numéro de téléphone invalide",
  151.      * min="10", minMessage="Numéro de téléphone invalide")
  152.      */
  153.     private $tel;
  155.     /**
  156.      * @ORM\OneToMany(targetEntity=InvoiceApplication::class, mappedBy="specialist")
  157.      */
  158.     private $invoiceApplications;
  160.     /**
  161.      * @ORM\Column(type="boolean", options={"default": 1})
  162.      */
  163.     private $isTva = true;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity=VisioEvent::class, mappedBy="specialist", orphanRemoval=true)
  167.      */
  168.     private $visioEvents;
  170.     /**
  171.      * @ORM\ManyToMany(targetEntity=VisioEventPromotion::class, mappedBy="specialists")
  172.      */
  173.     private $visioEventPromotions;
  175.     /**
  176.      * @ORM\Column(type="string", length=255, nullable=true)
  177.      */
  178.     private $status;
  180.     /**
  181.      * @ORM\Column(type="datetime", nullable=true)
  182.      * @Gedmo\Timestampable(on="update", field={"status"})
  183.      */
  184.     private $statusDate;
  186.     /**
  187.      * @ORM\Column(type="text", nullable=true)
  188.      */
  189.     private $statusMessage;
  191.     /**
  192.      * @ORM\Column(type="string", length=255, nullable=true)
  193.      */
  194.     private $identityCard;
  196.     /**
  197.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="identityCard")
  198.      * @Assert\File(
  199.      *     mimeTypes={"application/pdf"},
  200.      *     maxSize="2M",
  201.      * )
  202.      * @var File|null
  203.      */
  204.     private $identityCardFile;
  206.     /**
  207.      * @ORM\Column(type="string", length=255, nullable=true)
  208.      */
  209.     private $insurance;
  211.     /**
  212.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="insurance")
  213.      * @Assert\File(
  214.      *     mimeTypes={"application/pdf"},
  215.      *     maxSize="2M",
  216.      * )
  217.      * @var File|null
  218.      */
  219.     private $insuranceFile;
  221.     /**
  222.      * @ORM\Column(type="string", length=255, nullable=true)
  223.      */
  224.     private $degree;
  226.     /**
  227.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="degree")
  228.      * @Assert\File(
  229.      *     mimeTypes={"application/pdf"},
  230.      *     maxSize="2M",
  231.      * )
  232.      * @var File|null
  233.      */
  234.     private $degreeFile;
  236.     /**
  237.      * @ORM\Column(type="string", length=255, nullable=true)
  238.      */
  239.     private $rib;
  241.     /**
  242.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="rib")
  243.      * @Assert\File(
  244.      *     mimeTypes={"application/pdf"},
  245.      *     maxSize="2M",
  246.      * )
  247.      * @var File|null
  248.      */
  249.     private $ribFile;
  251.     /**
  252.      * @ORM\Column(type="boolean", options={"default": 1})
  253.      */
  254.     private $isVirtualEvent = true;
  256.     /**
  257.      * @ORM\Column(type="uuid", nullable=true)
  258.      */
  259.     private $uuid;
  261.     /**
  262.      * @ORM\Column(type="boolean", nullable=true, options={"default": "0"})
  263.      */
  264.     private $isAffiliated = false;
  266.     /**
  267.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="affiliatedSpecialists")
  268.      */
  269.     private $affiliatedCompany;
  271.     /**
  272.      * @ORM\ManyToMany(targetEntity=Company::class, inversedBy="specialists")
  273.      */
  274.     private $companies;
  275.     
  276.     private $specialistType;
  278.     /**
  279.      * @ORM\OneToMany(targetEntity=AffiliatedEventApplication::class, mappedBy="specialist", orphanRemoval=true)
  280.      */
  281.     private $affiliatedEventApplications;
  283.     /**
  284.      * @ORM\Column(type="string", length=255, nullable=true)
  285.      */
  286.     private $siret;
  287.    
  288.     /**
  289.      * @ORM\OneToMany(targetEntity=CancelEventApplication::class, mappedBy="specialist", orphanRemoval=true)
  290.      */
  291.     private $cancelEventApplications;
  293.     /**
  294.      * Custom field
  295.      * @Groups({"event:read"})
  296.      */
  297.     private $tags = null;
  299.     /**
  300.      * @ORM\Column(type="boolean", options={"default": 0})
  301.      */
  302.     private $fiveKWarningSent = true;
  304.     public function __construct()
  305.     {
  306.         $this->createdAt = new \DateTime();
  307.         $this->specialistTags = new ArrayCollection();
  308.         $this->events = new ArrayCollection();
  309.         $this->applications = new ArrayCollection();
  310.         $this->user = new User();
  311.         $this->workshops = new ArrayCollection();
  312.         $this->invoiceApplications = new ArrayCollection();
  313.         $this->visioEvents = new ArrayCollection();
  314.         $this->visioEventPromotions = new ArrayCollection();
  315.         $this->cancelEventApplications = new ArrayCollection();
  316.         $this->companies = new ArrayCollection();
  317.         $this->affiliatedEventApplications = new ArrayCollection();
  318.     }
  320.     public function getId(): ?int
  321.     {
  322.         return $this->id;
  323.     }
  325.     public function getFirstName(): ?string
  326.     {
  327.         return $this->firstName;
  328.     }
  330.     public function setFirstName(string $firstName): self
  331.     {
  332.         $this->firstName = $firstName;
  333.         $this->updateUsername();
  334.         return $this;
  335.     }
  337.     public function getLastName(): ?string
  338.     {
  339.         return $this->lastName;
  340.     }
  342.     public function setLastName(string $lastName): self
  343.     {
  344.         $this->lastName = $lastName;
  345.         $this->updateUsername();
  346.         return $this;
  347.     }
  349.     public function updateUsername()
  350.     {
  351.         if ($this->user instanceof User) {
  352.             $this->user->setName($this->getFirstName() . ' ' . $this->getLastName());
  353.         }
  354.     }
  356.     public function getCreatedAt(): ?\DateTime
  357.     {
  358.         return $this->createdAt;
  359.     }
  361.     public function setCreatedAt(\DateTime $createdAt): self
  362.     {
  363.         $this->createdAt = $createdAt;
  365.         return $this;
  366.     }
  368.     public function getImage(): ?string
  369.     {
  370.         return $this->image;
  371.     }
  373.     public function setImage(?string $image): self
  374.     {
  375.         $this->image = $image;
  377.         return $this;
  378.     }
  380.     public function getUser(): ?user
  381.     {
  382.         return $this->user;
  383.     }
  385.     public function setUser(User $user): self
  386.     {
  387.         $this->user = $user;
  388.         $user->setSpecialist($this);
  389.         $this->user->updateName();
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return File|null
  395.      */
  396.     public function getImageFile(): ?File
  397.     {
  398.         return $this->imageFile;
  399.     }
  401.     /**
  402.      * @param File|null $imageFile
  403.      * @return Specialist
  404.      */
  405.     public function setImageFile(?File $imageFile = null): Specialist
  406.     {
  407.         $this->imageFile = $imageFile;
  409.         if ($imageFile) {
  410.             // if 'updatedAt' is not defined in your entity, use another property
  411.             $this->updatedAt = new \DateTime('now');
  412.         }
  413.         return $this;
  414.     }
  416.     public function getUpdatedAt(): ?\DateTime
  417.     {
  418.         return $this->updatedAt;
  419.     }
  421.     public function setUpdatedAt(?\DateTime $updatedAt): self
  422.     {
  423.         $this->updatedAt = $updatedAt;
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return Collection|SpecialistTag[]
  430.      */
  431.     public function getSpecialistTags(): Collection
  432.     {
  433.         return $this->specialistTags;
  434.     }
  436.     public function setSpecialistTags(array $specialistTags): self
  437.     {
  438.         $this->specialistTags = new ArrayCollection();
  439.         if (is_array($specialistTags)) {
  440.             // foreach ($this->specialistTags as $key => $specialistTag) {
  441.             //     $this->removeSpecialistTag($specialistTag);
  442.             // }
  443.             // foreach ($specialistTags as $key => $specialistTag) {
  444.             //     $this->addSpecialistTag($specialistTag);
  445.             //     $specialistTags[$key]->setSpecialist($this);
  446.             // }
  447.             $this->specialistTags = new ArrayCollection($specialistTags);
  448.         }
  450.         return $this;
  451.     }
  453.     public function addSpecialistTag(SpecialistTag $specialistTag): self
  454.     {
  455.         if (!$this->specialistTags->contains($specialistTag)) {
  456.             $this->specialistTags[] = $specialistTag;
  457.             $specialistTag->setSpecialist($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeSpecialistTag(SpecialistTag $specialistTag): self
  464.     {
  465.         if ($this->specialistTags->removeElement($specialistTag)) {
  466.             // set the owning side to null (unless already changed)
  467.             if ($specialistTag->getSpecialist() === $this) {
  468.                 $specialistTag->setSpecialist(null);
  469.             }
  470.         }
  472.         return $this;
  473.     }
  475.     /**
  476.      * @return Collection|Event[]
  477.      */
  478.     public function getEvents(): Collection
  479.     {
  480.         return $this->events;
  481.     }
  483.     public function addEvent(Event $event): self
  484.     {
  485.         if (!$this->events->contains($event)) {
  486.             $this->events[] = $event;
  487.             $event->setSpecialist($this);
  488.         }
  490.         return $this;
  491.     }
  493.     public function removeEvent(Event $event): self
  494.     {
  495.         if ($this->events->removeElement($event)) {
  496.             // set the owning side to null (unless already changed)
  497.             if ($event->getSpecialist() === $this) {
  498.                 $event->setSpecialist(null);
  499.             }
  500.         }
  502.         return $this;
  503.     }
  505.     public function __toString()
  506.     {
  507.         return $this->firstName . ' ' . $this->lastName;
  508.     }
  510.     /**
  511.      * @ORM\PrePersist()
  512.      */
  513.     public function prePersist()
  514.     {
  515.         $this->user->setCategory(User::GROUP_SPECIALIST);
  516.         $this->user->addRole(User::ROLE_SPECIALIST);
  517.     }
  519.     /**
  520.      * @return Collection|SpecialistEventApplication[]
  521.      */
  522.     public function getApplications(): Collection
  523.     {
  524.         return $this->applications;
  525.     }
  527.     public function addApplication(SpecialistEventApplication $application): self
  528.     {
  529.         if (!$this->applications->contains($application)) {
  530.             $this->applications[] = $application;
  531.             $application->setSpecialist($this);
  532.         }
  534.         return $this;
  535.     }
  537.     public function removeApplication(SpecialistEventApplication $application): self
  538.     {
  539.         if ($this->applications->removeElement($application)) {
  540.             // set the owning side to null (unless already changed)
  541.             if ($application->getSpecialist() === $this) {
  542.                 $application->setSpecialist(null);
  543.             }
  544.         }
  546.         return $this;
  547.     }
  549.     public function getRadius(): ?float
  550.     {
  551.         return $this->radius;
  552.     }
  554.     public function setRadius(float $radius): self
  555.     {
  556.         $this->radius = $radius;
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection|Workshop[]
  563.      */
  564.     public function getWorkshops(): Collection
  565.     {
  566.         return $this->workshops;
  567.     }
  569.     public function addWorkshop(Workshop $workshop): self
  570.     {
  571.         if (!$this->workshops->contains($workshop)) {
  572.             $this->workshops[] = $workshop;
  573.             $workshop->setSpecialist($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeWorkshop(Workshop $workshop): self
  580.     {
  581.         if ($this->workshops->removeElement($workshop)) {
  582.             // set the owning side to null (unless already changed)
  583.             if ($workshop->getSpecialist() === $this) {
  584.                 $workshop->setSpecialist(null);
  585.             }
  586.         }
  588.         return $this;
  589.     }
  591.     public function getInComingEvents()
  592.     {
  593.         $inComingEvents = [];
  594.         if (!empty($this->getEvents()->toArray())) {
  595.             $today = new \DateTime("now");
  596.             foreach ($this->getEvents()->toArray() as $key => $event) {
  597.                 if ($event instanceof Event) {
  598.                     if (in_array($event->getStatus(), [Event::STATUS_VALID]) && $event->getStart() >= $today) {
  599.                         $inComingEvents[] = $event;
  600.                     }
  601.                 }
  602.             }
  603.         }
  605.         return $inComingEvents;
  606.     }
  608.     public function getPastEvents()
  609.     {
  610.         $pastEvents = [];
  611.         if (!empty($this->getEvents()->toArray())) {
  612.             $today = new \DateTime("now");
  613.             foreach ($this->getEvents()->toArray() as $key => $event) {
  614.                 if ($event instanceof Event) {
  615.                     if ($event->getEnd() <= $today) {
  616.                         $pastEvents[] = $event;
  617.                     }
  618.                 }
  619.             }
  620.         }
  622.         return $pastEvents;
  623.     }
  625.     public function getCanceledEvents()
  626.     {
  627.         $canceledEvents = [];
  628.         if (!empty($this->getEvents()->toArray())) {
  629.             foreach ($this->getEvents()->toArray() as $key => $event) {
  630.                 if ($event instanceof Event) {
  631.                     if (in_array($event->getStatus(), [Event::STATUS_CANCELED, Event::STATUS_CANCELED_MAIL])) {
  632.                         $canceledEvents[] = $event;
  633.                     }
  634.                 }
  635.             }
  636.         }
  638.         return $canceledEvents;
  639.     }
  641.     public function getDescription(): ?string
  642.     {
  643.         return $this->description;
  644.     }
  646.     public function setDescription(?string $description): self
  647.     {
  648.         $this->description = $description;
  650.         return $this;
  651.     }
  653.     public function getTel(): ?string
  654.     {
  655.         return $this->tel;
  656.     }
  658.     public function setTel(string $tel): self
  659.     {
  660.         $this->tel = $tel;
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection<int, InvoiceApplication>
  667.      */
  668.     public function getInvoiceApplications(): Collection
  669.     {
  670.         return $this->invoiceApplications;
  671.     }
  673.     public function addInvoiceApplication(InvoiceApplication $invoiceApplication): self
  674.     {
  675.         if (!$this->invoiceApplications->contains($invoiceApplication)) {
  676.             $this->invoiceApplications[] = $invoiceApplication;
  677.             $invoiceApplication->setSpecialist($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeInvoiceApplication(InvoiceApplication $invoiceApplication): self
  684.     {
  685.         if ($this->invoiceApplications->removeElement($invoiceApplication)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($invoiceApplication->getSpecialist() === $this) {
  688.                 $invoiceApplication->setSpecialist(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     public function getPriceByEvent(Event $event)
  696.     {
  697.         $price = null;
  698.         foreach ($this->specialistTags as $key => $specialistTag) {
  699.             if ($specialistTag->getTag() == $event->getWorkshop()->getTag()) {
  700.                 $price = $specialistTag->getPrice();
  701.                 break;
  702.             }
  703.         }
  704.         return $price;
  705.     }
  707.     public function getIsTva(): ?bool
  708.     {
  709.         return $this->isTva;
  710.     }
  712.     public function setIsTva(bool $isTva): self
  713.     {
  714.         $this->isTva = $isTva;
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return Collection<int, CancelEventApplication>
  721.      */
  722.     public function getCancelEventApplications(): Collection
  723.     {
  724.         return $this->cancelEventApplications;
  725.     }
  727.     public function addCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  728.     {
  729.         if (!$this->cancelEventApplications->contains($cancelEventApplication)) {
  730.             $this->cancelEventApplications[] = $cancelEventApplication;
  731.             $cancelEventApplication->setSpecialist($this);
  732.         }
  734.         return $this;
  735.     }
  737.     public function removeCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  738.     {
  739.         if ($this->cancelEventApplications->removeElement($cancelEventApplication)) {
  740.             // set the owning side to null (unless already changed)
  741.             if ($cancelEventApplication->getSpecialist() === $this) {
  742.                 $cancelEventApplication->setSpecialist(null);
  743.             }
  744.         }
  746.         return $this;
  747.     }
  749.     public function getIsVirtualEvent(): ?bool
  750.     {
  751.         return $this->isVirtualEvent;
  752.     }
  754.     public function setIsVirtualEvent(bool $isVirtualEvent): self
  755.     {
  756.         $this->isVirtualEvent = $isVirtualEvent;
  758.         return $this;
  759.     }
  761.     public function getStatus(): ?string
  762.     {
  763.         return $this->status;
  764.     }
  766.     public function setStatus(?string $status): self
  767.     {
  768.         $this->status = $status;
  770.         return $this;
  771.     }
  773.     public function getStatusDate(): ?\DateTimeInterface
  774.     {
  775.         return $this->statusDate;
  776.     }
  778.     public function setStatusDate(?\DateTimeInterface $statusDate): self
  779.     {
  780.         $this->statusDate = $statusDate;
  781.         return $this;
  782.     }
  784.     public function getIdentityCard(): ?string
  785.     {
  786.         return $this->identityCard;
  787.     }
  789.     /**
  790.      * @return File|null
  791.      */
  792.     public function getIdentityCardFile(): ?File
  793.     {
  794.         return $this->identityCardFile;
  795.     }
  797.     public function setIdentityCard(?string $identityCard): self
  798.     {
  799.         $this->identityCard = $identityCard;
  801.         return $this;
  802.     }
  804.     /**
  805.      * @param File|null $identityCardFile
  806.      * @return Specialist
  807.      */
  808.     public function setIdentityCardFile(?File $identityCardFile = null): Specialist
  809.     {
  810.         $this->identityCardFile = $identityCardFile;
  812.         if ($identityCardFile) {
  813.             // if 'updatedAt' is not defined in your entity, use another property
  814.             $this->updatedAt = new \DateTime('now');
  815.         }
  816.         return $this;
  817.     }
  819.     public function getInsurance(): ?string
  820.     {
  821.         return $this->insurance;
  822.     }
  824.     /**
  825.      * @return File|null
  826.      */
  827.     public function getInsuranceFile(): ?File
  828.     {
  829.         return $this->insuranceFile;
  830.     }
  832.     public function setInsurance(?string $insurance): self
  833.     {
  834.         $this->insurance = $insurance;
  836.         return $this;
  837.     }
  839.     /**
  840.      * @param File|null $insuranceFile
  841.      * @return Specialist
  842.      */
  843.     public function setInsuranceFile(?File $insuranceFile = null): Specialist
  844.     {
  845.         $this->insuranceFile = $insuranceFile;
  847.         if ($insuranceFile) {
  848.             // if 'updatedAt' is not defined in your entity, use another property
  849.             $this->updatedAt = new \DateTime('now');
  850.         }
  851.         return $this;
  852.     }
  854.     public function getDegree(): ?string
  855.     {
  856.         return $this->degree;
  857.     }
  859.     /**
  860.      * @return File|null
  861.      */
  862.     public function getDegreeFile(): ?File
  863.     {
  864.         return $this->degreeFile;
  865.     }
  867.     public function setDegree(?string $degree): self
  868.     {
  869.         $this->degree = $degree;
  871.         return $this;
  872.     }
  874.     /**
  875.      * @param File|null $degreeFile
  876.      * @return Specialist
  877.      */
  878.     public function setDegreeFile(?File $degreeFile = null): Specialist
  879.     {
  880.         $this->degreeFile = $degreeFile;
  882.         if ($degreeFile) {
  883.             // if 'updatedAt' is not defined in your entity, use another property
  884.             $this->updatedAt = new \DateTime('now');
  885.         }
  886.         return $this;
  887.     }
  889.     public function getRib(): ?string
  890.     {
  891.         return $this->rib;
  892.     }
  894.     /**
  895.      * @return File|null
  896.      */
  897.     public function getRibFile(): ?File
  898.     {
  899.         return $this->ribFile;
  900.     }
  902.     public function setRib(?string $rib): self
  903.     {
  904.         $this->rib = $rib;
  906.         return $this;
  907.     }
  909.     /**
  910.      * @param File|null $ribFile
  911.      * @return Specialist
  912.      */
  913.     public function setRibFile(?File $ribFile = null): Specialist
  914.     {
  915.         $this->ribFile = $ribFile;
  917.         if ($ribFile) {
  918.             // if 'updatedAt' is not defined in your entity, use another property
  919.             $this->updatedAt = new \DateTime('now');
  920.         }
  921.         return $this;
  922.     }
  924.     /**
  925.      * @return Collection<int, VisioEvent>
  926.      */
  927.     public function getVisioEvents(): Collection
  928.     {
  929.         return $this->visioEvents;
  930.     }
  932.     public function addVisioEvent(VisioEvent $visioEvent): self
  933.     {
  934.         if (!$this->visioEvents->contains($visioEvent)) {
  935.             $this->visioEvents[] = $visioEvent;
  936.             $visioEvent->setSpecialist($this);
  937.         }
  939.         return $this;
  940.     }
  942.     public function removeVisioEvent(VisioEvent $visioEvent): self
  943.     {
  944.         if ($this->visioEvents->removeElement($visioEvent)) {
  945.             // set the owning side to null (unless already changed)
  946.             if ($visioEvent->getSpecialist() === $this) {
  947.                 $visioEvent->setSpecialist(null);
  948.             }
  949.         }
  951.         return $this;
  952.     }
  953.     
  954.     public function getStatusMessage(): ?string
  955.     {
  956.         return $this->statusMessage;
  957.     }
  959.     public function setStatusMessage(?string $statusMessage): self
  960.     {
  961.         $this->statusMessage = $statusMessage;
  963.         return $this;
  964.     }
  965.     /**
  966.      * @return VisioEvent[]
  967.      */
  968.     public function dayVisios(?\DateTime $dateTime = null, int $max = 5): array
  969.     {
  970.         $result = [];
  971.         if ($dateTime instanceof \DateTime) {
  972.             $today = $dateTime->format('Y-m-d');
  973.         } else {
  974.             $today = (new \DateTime())->format('Y-m-d');
  975.         }
  976.         foreach ($this->getVisioEvents() as $visioEvent) {
  977.             if ($visioEvent->getStart()->format('Y-m-d') == $today &&
  978.             count($result) < $max && $visioEvent->getStart() > new \DateTime()) {
  979.                 $result[] = $visioEvent;
  980.             }
  981.         }
  982.         return $result;
  983.     }
  984.     /**
  985.      * @return VisioEvent[]
  986.      */
  987.     public function dayVisiosFiltered(?\DateTime $dateTime = null, int $max = 5, bool $valid = false): array
  988.     {
  989.         $result = [];
  990.         if ($dateTime instanceof \DateTime) {
  991.             $today = $dateTime->format('Y-m-d');
  992.         } else {
  993.             $today = (new \DateTime())->format('Y-m-d');
  994.         }
  995.         foreach ($this->getVisioEvents() as $visioEvent) {
  996.             if ($visioEvent->getStart()->format('Y-m-d') == $today &&
  997.                 count($result) < $max && (!$valid || $visioEvent->isOpen())) {
  998.                 $result[] = $visioEvent;
  999.             }
  1000.         }
  1001.         return $result;
  1002.     }
  1004.     /**
  1005.      * @param \DateTime|null $dateTime
  1006.      * @param int $max
  1007.      * @param bool $valid
  1008.      * @param int $rank
  1009.      * @return VisioEvent[]
  1010.      */
  1011.     public function dayVisiosNextDay(?\DateTime $dateTime = null, int $max = 5, bool $valid = false, int $rank = 0): array
  1012.     {
  1013.         if ($dateTime == null){
  1014.             $dateTime = new \DateTime();
  1015.         }
  1016.         $result = $this->dayVisiosFiltered($dateTime, $max, $valid);
  1017.         if (empty($result) && $rank < 10){
  1018.             $dateTime->modify('+1 day');
  1019.             $result = $this->dayVisiosNextDay($dateTime, $max, $valid, ++$rank);
  1020.         }
  1021.         return $result;
  1022.     }
  1024.     /**
  1025.      * @return Collection<int, VisioEventPromotion>
  1026.      */
  1027.     public function getVisioEventPromotions(): Collection
  1028.     {
  1029.         return $this->visioEventPromotions;
  1030.     }
  1032.     public function addVisioEventPromotion(VisioEventPromotion $visioEventPromotion): self
  1033.     {
  1034.         if (!$this->visioEventPromotions->contains($visioEventPromotion)) {
  1035.             $this->visioEventPromotions[] = $visioEventPromotion;
  1036.             $visioEventPromotion->addSpecialist($this);
  1037.         }
  1039.         return $this;
  1040.     }
  1041.     
  1043.     public function removeVisioEventPromotion(VisioEventPromotion $visioEventPromotion): self
  1044.     {
  1045.         if ($this->visioEventPromotions->removeElement($visioEventPromotion)) {
  1046.             $visioEventPromotion->removeSpecialist($this);
  1047.         }
  1049.         return $this;
  1050.     }
  1052.     /**
  1053.      * @Groups({"search"})
  1054.      * @SerializedName("text")
  1055.      * @return string
  1056.      */
  1057.     public function getText(): string
  1058.     {
  1059.         return (string)$this;
  1060.     }
  1062.     public function getUuid()
  1063.     {
  1064.         return $this->uuid;
  1065.     }
  1067.     public function setUuid($uuid): self
  1068.     {
  1069.         $this->uuid = $uuid;
  1071.         return $this;
  1072.     }
  1074.     /**
  1075.      * @return bool
  1076.      * @var Datetime $start
  1077.      * @var Datetime $end
  1078.      * Permet de savoir si il est disponible en fonction d'une date de début et de fin
  1079.      */
  1080.     public function isAvailable(\DateTime $start, \DateTime $end): bool
  1081.     {
  1082.         $isAvailable = true;
  1083.         foreach($this->getEvents()->toArray() as $event)
  1084.         {
  1085.             if($event->isInComing()) {
  1086.                 if($event->getStart() >= $start && $event->getStart() <= $end
  1087.                     && $event->getEnd() >= $start && $event->getEnd() <= $end) {
  1088.                         $isAvailable = false;
  1089.                 }
  1090.             }
  1091.         }
  1092.         return $isAvailable;
  1093.     }
  1095.     public function getIsAffiliated(): ?bool
  1096.     {
  1097.         return $this->isAffiliated;
  1098.     }
  1100.     public function setIsAffiliated(?bool $isAffiliated): self
  1101.     {
  1102.         $this->isAffiliated = $isAffiliated;
  1104.         return $this;
  1105.     }
  1107.     public function getAffiliatedCompany(): ?Company
  1108.     {
  1109.         return $this->affiliatedCompany;
  1110.     }
  1112.     public function setAffiliatedCompany(?Company $affiliatedCompany): self
  1113.     {
  1114.         $this->affiliatedCompany = $affiliatedCompany;
  1116.         return $this;
  1117.     }
  1119.     /**
  1120.      * @return Collection<int, Company>
  1121.      */
  1122.     public function getCompanies(): Collection
  1123.     {
  1124.         return $this->companies;
  1125.     }
  1127.     public function setCompanies(Collection $companies): self
  1128.     {
  1129.         $this->companies = $companies;
  1130.         return $this;
  1131.     }
  1133.     public function addCompany(Company $company): self
  1134.     {
  1135.         if (!$this->companies->contains($company)) {
  1136.             $this->companies[] = $company;
  1137.         }
  1139.         return $this;
  1140.     }
  1142.     public function removeCompany(Company $company): self
  1143.     {
  1144.         $this->companies->removeElement($company);
  1146.         return $this;
  1147.     }
  1149.     public function getspecialistType(): ?string
  1150.     {
  1151.        
  1152.        
  1153.         return $this->specialistType;
  1154.     }
  1156.     public function setspecialistType(?string $specialistType): self
  1157.     {
  1158.         $this->specialistType = $specialistType;
  1160.         return $this;
  1161.     }
  1163.     /**
  1164.      * @return Collection<int, AffiliatedEventApplication>
  1165.      */
  1166.     public function getAffiliatedEventApplications(): Collection
  1167.     {
  1168.         return $this->affiliatedEventApplications;
  1169.     }
  1171.     public function addAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1172.     {
  1173.         if (!$this->affiliatedEventApplications->contains($affiliatedEventApplication)) {
  1174.             $this->affiliatedEventApplications[] = $affiliatedEventApplication;
  1175.             $affiliatedEventApplication->setSpecialist($this);
  1176.         }
  1178.         return $this;
  1179.     }
  1181.     public function removeAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1182.     {
  1183.         if ($this->affiliatedEventApplications->removeElement($affiliatedEventApplication)) {
  1184.             // set the owning side to null (unless already changed)
  1185.             if ($affiliatedEventApplication->getSpecialist() === $this) {
  1186.                 $affiliatedEventApplication->setSpecialist(null);
  1187.             }
  1188.         }
  1190.         return $this;
  1191.     }
  1193.     public function getSiret(): ?string
  1194.     {
  1195.         return $this->siret;
  1196.     }
  1198.     public function setSiret(?string $siret): self
  1199.     {
  1200.         $this->siret = $siret;
  1202.         return $this;
  1203.     }
  1204.    
  1205.     /**
  1206.      * @return Collection<int, Tag>
  1207.      */
  1208.     public function getTags(): ?Collection
  1209.     {
  1210.         if(!$this->specialistTags->isEmpty()) {
  1211.             $this->tags = new ArrayCollection();
  1212.             
  1213.             foreach($this->specialistTags as $specialistTag){
  1214.                 $this->tags->add($specialistTag->getTag());
  1215.             }
  1216.         }
  1218.         return $this->tags;
  1219.     }
  1221.     public function setTags(Collection $tags): self
  1222.     {
  1223.         $this->tags = $tags;
  1224.         return $this;
  1225.     }
  1227.     public function addTag(Tag $tag): self
  1228.     {
  1229.         if (!$this->tags->contains($tag)) {
  1230.             $this->tags[] = $tag;
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     public function removeTag(Tag $tag): self
  1237.     {
  1238.         $this->tags->removeElement($tag);
  1240.         return $this;
  1241.     }
  1243.     public function getImageUrl(): ?string
  1244.     {
  1245.         return $this->imageUrl;
  1246.     }
  1248.     public function setImageUrl(string $imageUrl): self
  1249.     {
  1250.         $this->imageUrl = $imageUrl;
  1252.         return $this;
  1253.     }
  1255.     public function isFiveKWarningSent(): ?bool
  1256.     {
  1257.         return $this->fiveKWarningSent;
  1258.     }
  1260.     public function setIsFiveKWarningSent(bool $fiveKWarningSent): self
  1261.     {
  1262.         $this->fiveKWarningSent = $fiveKWarningSent;
  1264.         return $this;
  1265.     }
  1266. }