src/Entity/Specialist.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\Address;
  6. use App\Repository\SpecialistRepository;
  7. use DateTime;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Symfony\Component\Serializer\Annotation\SerializedName;
  14. use Symfony\Component\Validator\Constraints as Assert;
  15. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  16. use Gedmo\Mapping\Annotation as Gedmo;
  18. /**
  19.  * @ORM\Entity(repositoryClass=SpecialistRepository::class)
  20.  * @Vich\Uploadable
  21.  * @ORM\HasLifecycleCallbacks()
  22.  */
  23. class Specialist
  24. {
  26.     const STATUS_WAITING_MAIL_CONFIRMATION = 'waiting_mail_confirmation'; // specialist has been created but must confirm by clicking on link in email
  27.     const STATUS_WAITING_ULTEAM_CONFIRMATION = 'waiting_ulteam_confirmation'; // specialist has validated mail but is waiting for ULTEAM to confirm registration
  28.     const STATUS_REFUSED = 'refused'; // specialist registration has been refused by ULTEAM
  29.     const STATUS_GRANTED = 'granted'; // specialist has been granted full access to his back office by ULTEAM
  30.     
  31.     /**
  32.      * Available statuses for the specialist
  33.      */
  34.     const STATUSES = [
  35.         self::STATUS_WAITING_MAIL_CONFIRMATION,
  36.         self::STATUS_WAITING_ULTEAM_CONFIRMATION,
  37.         self::STATUS_REFUSED,
  38.         self::STATUS_GRANTED,
  39.     ];
  41.     /**
  42.      * Available types for the specialist
  43.      */
  44.     const TYPES = [
  45.         100 => 'Indépendant',
  46.         200 => 'Affilié',
  47.         300 => '100% Affilié'
  48.     ];
  50.     use Address;
  52.     /**
  53.      * @ORM\Id
  54.      * @ORM\GeneratedValue
  55.      * @ORM\Column(type="integer")
  56.      * @Groups({"search"})
  57.      */
  58.     private $id;
  60.     /**
  61.      * @ORM\Column(type="string", length=255)
  62.      * @Assert\NotBlank
  63.      */
  64.     private $firstName;
  66.     /**
  67.      * @ORM\Column(type="string", length=255)
  68.      * @Assert\NotBlank
  69.      */
  70.     private $lastName;
  72.     /**
  73.      * @ORM\Column(type="datetime")
  74.      * @var DateTime
  75.      */
  76.     private $createdAt;
  78.     /**
  79.      * @ORM\Column(type="string", length=255, nullable=true)
  80.      */
  81.     private $image;
  83.     /**
  84.      * @Vich\UploadableField(mapping="specialists_images", fileNameProperty="image")
  85.      * @Assert\File(
  86.      *     mimeTypes={"image/jpeg", "image/gif", "image/png"},
  87.      *     maxSize="700Ki",
  88.      * )
  89.      * @var File|null
  90.      */
  91.     private $imageFile;
  93.     /**
  94.      * @ORM\OneToOne(targetEntity=User::class, inversedBy="specialist", cascade={"persist", "remove"})
  95.      * @ORM\JoinColumn(nullable=false)
  96.      * @Assert\Valid
  97.      */
  98.     private $user;
  100.     /**
  101.      * @ORM\Column(type="datetime", nullable=true)
  102.      */
  103.     private $updatedAt;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=SpecialistTag::class, mappedBy="specialist", cascade={"all"})
  107.      */
  108.     private $specialistTags;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=Event::class, mappedBy="specialist")
  112.      */
  113.     private $events;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=SpecialistEventApplication::class, mappedBy="specialist", orphanRemoval=true)
  117.      */
  118.     private $applications;
  120.     /**
  121.      * Search radius in meters
  122.      * @ORM\Column(type="float")
  123.      */
  124.     private $radius = 5;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=Workshop::class, mappedBy="specialist")
  128.      */
  129.     private $workshops;
  131.     /**
  132.      * @ORM\Column(type="text", nullable=true)
  133.      */
  134.     private $description;
  136.     /**
  137.      * @ORM\Column(type="string", length=255, nullable=true)
  138.      * @Assert\Length(max="12", maxMessage="Numéro de téléphone invalide",
  139.      * min="10", minMessage="Numéro de téléphone invalide")
  140.      */
  141.     private $tel;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=InvoiceApplication::class, mappedBy="specialist")
  145.      */
  146.     private $invoiceApplications;
  148.     /**
  149.      * @ORM\Column(type="boolean", options={"default": 1})
  150.      */
  151.     private $isTva = true;
  153.     /**
  154.      * @ORM\OneToMany(targetEntity=VisioEvent::class, mappedBy="specialist", orphanRemoval=true)
  155.      */
  156.     private $visioEvents;
  158.     /**
  159.      * @ORM\ManyToMany(targetEntity=VisioEventPromotion::class, mappedBy="specialists")
  160.      */
  161.     private $visioEventPromotions;
  163.     /**
  164.      * @ORM\Column(type="string", length=255, nullable=true)
  165.      */
  166.     private $status;
  168.     /**
  169.      * @ORM\Column(type="datetime", nullable=true)
  170.      * @Gedmo\Timestampable(on="update", field={"status"})
  171.      */
  172.     private $statusDate;
  174.     /**
  175.      * @ORM\Column(type="text", nullable=true)
  176.      */
  177.     private $statusMessage;
  179.     /**
  180.      * @ORM\Column(type="string", length=255, nullable=true)
  181.      */
  182.     private $identityCard;
  184.     /**
  185.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="identityCard")
  186.      * @Assert\File(
  187.      *     mimeTypes={"application/pdf"},
  188.      *     maxSize="2M",
  189.      * )
  190.      * @var File|null
  191.      */
  192.     private $identityCardFile;
  194.     /**
  195.      * @ORM\Column(type="string", length=255, nullable=true)
  196.      */
  197.     private $insurance;
  199.     /**
  200.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="insurance")
  201.      * @Assert\File(
  202.      *     mimeTypes={"application/pdf"},
  203.      *     maxSize="2M",
  204.      * )
  205.      * @var File|null
  206.      */
  207.     private $insuranceFile;
  209.     /**
  210.      * @ORM\Column(type="string", length=255, nullable=true)
  211.      */
  212.     private $degree;
  214.     /**
  215.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="degree")
  216.      * @Assert\File(
  217.      *     mimeTypes={"application/pdf"},
  218.      *     maxSize="2M",
  219.      * )
  220.      * @var File|null
  221.      */
  222.     private $degreeFile;
  224.     /**
  225.      * @ORM\Column(type="string", length=255, nullable=true)
  226.      */
  227.     private $rib;
  229.     /**
  230.      * @Vich\UploadableField(mapping="specialists_documents", fileNameProperty="rib")
  231.      * @Assert\File(
  232.      *     mimeTypes={"application/pdf"},
  233.      *     maxSize="2M",
  234.      * )
  235.      * @var File|null
  236.      */
  237.     private $ribFile;
  239.     /**
  240.      * @ORM\Column(type="boolean", options={"default": 1})
  241.      */
  242.     private $isVirtualEvent = true;
  244.     /**
  245.      * @ORM\Column(type="uuid", nullable=true)
  246.      */
  247.     private $uuid;
  249.     /**
  250.      * @ORM\Column(type="boolean", nullable=true)
  251.      */
  252.     private $isAffiliated;
  254.     /**
  255.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="affiliatedSpecialists")
  256.      */
  257.     private $affiliatedCompany;
  259.     /**
  260.      * @ORM\ManyToMany(targetEntity=Company::class, inversedBy="specialists")
  261.      */
  262.     private $companies;
  263.     
  264.     private $specialistType;
  266.     /**
  267.      * @ORM\OneToMany(targetEntity=AffiliatedEventApplication::class, mappedBy="specialist", orphanRemoval=true)
  268.      */
  269.     private $affiliatedEventApplications;
  271.     /**
  272.      * @ORM\Column(type="string", length=255, nullable=true)
  273.      */
  274.     private $siret;
  275.    
  276.    
  278.     public function __construct()
  279.     {
  280.         $this->createdAt = new DateTime();
  281.         $this->specialistTags = new ArrayCollection();
  282.         $this->events = new ArrayCollection();
  283.         $this->applications = new ArrayCollection();
  284.         $this->user = new User();
  285.         $this->workshops = new ArrayCollection();
  286.         $this->invoiceApplications = new ArrayCollection();
  287.         $this->visioEvents = new ArrayCollection();
  288.         $this->visioEventPromotions = new ArrayCollection();
  289.         $this->cancelEventApplications = new ArrayCollection();
  290.         $this->companies = new ArrayCollection();
  291.         $this->affiliatedEventApplications = new ArrayCollection();
  292.     }
  294.     public function getId(): ?int
  295.     {
  296.         return $this->id;
  297.     }
  299.     public function getFirstName(): ?string
  300.     {
  301.         return $this->firstName;
  302.     }
  304.     public function setFirstName(string $firstName): self
  305.     {
  306.         $this->firstName = $firstName;
  307.         $this->updateUsername();
  308.         return $this;
  309.     }
  311.     public function getLastName(): ?string
  312.     {
  313.         return $this->lastName;
  314.     }
  316.     public function setLastName(string $lastName): self
  317.     {
  318.         $this->lastName = $lastName;
  319.         $this->updateUsername();
  320.         return $this;
  321.     }
  323.     public function updateUsername()
  324.     {
  325.         if ($this->user instanceof User) {
  326.             $this->user->setName($this->getFirstName() . ' ' . $this->getLastName());
  327.         }
  328.     }
  330.     public function getCreatedAt(): ?DateTime
  331.     {
  332.         return $this->createdAt;
  333.     }
  335.     public function setCreatedAt(DateTime $createdAt): self
  336.     {
  337.         $this->createdAt = $createdAt;
  339.         return $this;
  340.     }
  342.     public function getImage(): ?string
  343.     {
  344.         return $this->image;
  345.     }
  347.     public function setImage(?string $image): self
  348.     {
  349.         $this->image = $image;
  351.         return $this;
  352.     }
  354.     public function getUser(): ?user
  355.     {
  356.         return $this->user;
  357.     }
  359.     public function setUser(User $user): self
  360.     {
  361.         $this->user = $user;
  362.         $user->setSpecialist($this);
  363.         $this->user->updateName();
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return File|null
  369.      */
  370.     public function getImageFile(): ?File
  371.     {
  372.         return $this->imageFile;
  373.     }
  375.     /**
  376.      * @param File|null $imageFile
  377.      * @return Specialist
  378.      */
  379.     public function setImageFile(?File $imageFile = null): Specialist
  380.     {
  381.         $this->imageFile = $imageFile;
  383.         if ($imageFile) {
  384.             // if 'updatedAt' is not defined in your entity, use another property
  385.             $this->updatedAt = new DateTime('now');
  386.         }
  387.         return $this;
  388.     }
  390.     public function getUpdatedAt(): ?DateTime
  391.     {
  392.         return $this->updatedAt;
  393.     }
  395.     public function setUpdatedAt(?DateTime $updatedAt): self
  396.     {
  397.         $this->updatedAt = $updatedAt;
  399.         return $this;
  400.     }
  402.     /**
  403.      * @return Collection|SpecialistTag[]
  404.      */
  405.     public function getSpecialistTags(): Collection
  406.     {
  407.         return $this->specialistTags;
  408.     }
  410.     public function setSpecialistTags(array $specialistTags): self
  411.     {
  412.         $this->specialistTags = new ArrayCollection();
  413.         if (is_array($specialistTags)) {
  414.             // foreach ($this->specialistTags as $key => $specialistTag) {
  415.             //     $this->removeSpecialistTag($specialistTag);
  416.             // }
  417.             // foreach ($specialistTags as $key => $specialistTag) {
  418.             //     $this->addSpecialistTag($specialistTag);
  419.             //     $specialistTags[$key]->setSpecialist($this);
  420.             // }
  421.             $this->specialistTags = new ArrayCollection($specialistTags);
  422.         }
  424.         return $this;
  425.     }
  427.     public function addSpecialistTag(SpecialistTag $specialistTag): self
  428.     {
  429.         if (!$this->specialistTags->contains($specialistTag)) {
  430.             $this->specialistTags[] = $specialistTag;
  431.             $specialistTag->setSpecialist($this);
  432.         }
  434.         return $this;
  435.     }
  437.     public function removeSpecialistTag(SpecialistTag $specialistTag): self
  438.     {
  439.         if ($this->specialistTags->removeElement($specialistTag)) {
  440.             // set the owning side to null (unless already changed)
  441.             if ($specialistTag->getSpecialist() === $this) {
  442.                 $specialistTag->setSpecialist(null);
  443.             }
  444.         }
  446.         return $this;
  447.     }
  449.     /**
  450.      * Transforms the specialist tags to a tags option
  451.      * @return SpecialistTag[]
  452.      */
  453.     public function getTags(): array
  454.     {
  455.         $res = [];
  456.         if (!empty($this->specialistTags)) {
  457.             $res = array_map(function ($element) {
  458.                 if ($element instanceof SpecialistTag) {
  459.                     return $element->getTag();
  460.                 }
  461.             }, $this->specialistTags->toArray());
  462.         }
  463.         return $res;
  464.     }
  466.     /**
  467.      * @return Collection|Event[]
  468.      */
  469.     public function getEvents(): Collection
  470.     {
  471.         return $this->events;
  472.     }
  474.     public function addEvent(Event $event): self
  475.     {
  476.         if (!$this->events->contains($event)) {
  477.             $this->events[] = $event;
  478.             $event->setSpecialist($this);
  479.         }
  481.         return $this;
  482.     }
  484.     public function removeEvent(Event $event): self
  485.     {
  486.         if ($this->events->removeElement($event)) {
  487.             // set the owning side to null (unless already changed)
  488.             if ($event->getSpecialist() === $this) {
  489.                 $event->setSpecialist(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  496.     public function __toString()
  497.     {
  498.         return $this->firstName . ' ' . $this->lastName;
  499.     }
  501.     /**
  502.      * @ORM\PrePersist()
  503.      */
  504.     public function prePersist()
  505.     {
  506.         $this->user->setCategory(User::GROUP_SPECIALIST);
  507.         $this->user->addRole(User::ROLE_SPECIALIST);
  508.     }
  510.     /**
  511.      * @return Collection|SpecialistEventApplication[]
  512.      */
  513.     public function getApplications(): Collection
  514.     {
  515.         return $this->applications;
  516.     }
  518.     public function addApplication(SpecialistEventApplication $application): self
  519.     {
  520.         if (!$this->applications->contains($application)) {
  521.             $this->applications[] = $application;
  522.             $application->setSpecialist($this);
  523.         }
  525.         return $this;
  526.     }
  528.     public function removeApplication(SpecialistEventApplication $application): self
  529.     {
  530.         if ($this->applications->removeElement($application)) {
  531.             // set the owning side to null (unless already changed)
  532.             if ($application->getSpecialist() === $this) {
  533.                 $application->setSpecialist(null);
  534.             }
  535.         }
  537.         return $this;
  538.     }
  540.     public function getRadius(): ?float
  541.     {
  542.         return $this->radius;
  543.     }
  545.     public function setRadius(float $radius): self
  546.     {
  547.         $this->radius = $radius;
  549.         return $this;
  550.     }
  552.     /**
  553.      * @return Collection|Workshop[]
  554.      */
  555.     public function getWorkshops(): Collection
  556.     {
  557.         return $this->workshops;
  558.     }
  560.     public function addWorkshop(Workshop $workshop): self
  561.     {
  562.         if (!$this->workshops->contains($workshop)) {
  563.             $this->workshops[] = $workshop;
  564.             $workshop->setSpecialist($this);
  565.         }
  567.         return $this;
  568.     }
  570.     public function removeWorkshop(Workshop $workshop): self
  571.     {
  572.         if ($this->workshops->removeElement($workshop)) {
  573.             // set the owning side to null (unless already changed)
  574.             if ($workshop->getSpecialist() === $this) {
  575.                 $workshop->setSpecialist(null);
  576.             }
  577.         }
  579.         return $this;
  580.     }
  582.     public function getInComingEvents()
  583.     {
  584.         $inComingEvents = [];
  585.         if (!empty($this->getEvents()->toArray())) {
  586.             $today = new \DateTime("now");
  587.             foreach ($this->getEvents()->toArray() as $key => $event) {
  588.                 if ($event instanceof Event) {
  589.                     if (in_array($event->getStatus(), [Event::STATUS_VALID]) && $event->getStart() >= $today) {
  590.                         $inComingEvents[] = $event;
  591.                     }
  592.                 }
  593.             }
  594.         }
  596.         return $inComingEvents;
  597.     }
  599.     public function getPastEvents()
  600.     {
  601.         $pastEvents = [];
  602.         if (!empty($this->getEvents()->toArray())) {
  603.             $today = new \DateTime("now");
  604.             foreach ($this->getEvents()->toArray() as $key => $event) {
  605.                 if ($event instanceof Event) {
  606.                     if ($event->getEnd() <= $today) {
  607.                         $pastEvents[] = $event;
  608.                     }
  609.                 }
  610.             }
  611.         }
  613.         return $pastEvents;
  614.     }
  616.     public function getCanceledEvents()
  617.     {
  618.         $canceledEvents = [];
  619.         if (!empty($this->getEvents()->toArray())) {
  620.             foreach ($this->getEvents()->toArray() as $key => $event) {
  621.                 if ($event instanceof Event) {
  622.                     if (in_array($event->getStatus(), [Event::STATUS_CANCELED, Event::STATUS_CANCELED_MAIL])) {
  623.                         $canceledEvents[] = $event;
  624.                     }
  625.                 }
  626.             }
  627.         }
  629.         return $canceledEvents;
  630.     }
  632.     public function getDescription(): ?string
  633.     {
  634.         return $this->description;
  635.     }
  637.     public function setDescription(?string $description): self
  638.     {
  639.         $this->description = $description;
  641.         return $this;
  642.     }
  644.     public function getTel(): ?string
  645.     {
  646.         return $this->tel;
  647.     }
  649.     public function setTel(string $tel): self
  650.     {
  651.         $this->tel = $tel;
  653.         return $this;
  654.     }
  656.     /**
  657.      * @return Collection<int, InvoiceApplication>
  658.      */
  659.     public function getInvoiceApplications(): Collection
  660.     {
  661.         return $this->invoiceApplications;
  662.     }
  664.     public function addInvoiceApplication(InvoiceApplication $invoiceApplication): self
  665.     {
  666.         if (!$this->invoiceApplications->contains($invoiceApplication)) {
  667.             $this->invoiceApplications[] = $invoiceApplication;
  668.             $invoiceApplication->setSpecialist($this);
  669.         }
  671.         return $this;
  672.     }
  674.     public function removeInvoiceApplication(InvoiceApplication $invoiceApplication): self
  675.     {
  676.         if ($this->invoiceApplications->removeElement($invoiceApplication)) {
  677.             // set the owning side to null (unless already changed)
  678.             if ($invoiceApplication->getSpecialist() === $this) {
  679.                 $invoiceApplication->setSpecialist(null);
  680.             }
  681.         }
  683.         return $this;
  684.     }
  686.     public function getPriceByEvent(Event $event)
  687.     {
  688.         $price = null;
  689.         foreach ($this->specialistTags as $key => $specialistTag) {
  690.             if ($specialistTag->getTag() == $event->getWorkshop()->getTag()) {
  691.                 $price = $specialistTag->getPrice();
  692.                 break;
  693.             }
  694.         }
  695.         return $price;
  696.     }
  698.     public function getIsTva(): ?bool
  699.     {
  700.         return $this->isTva;
  701.     }
  703.     public function setIsTva(bool $isTva): self
  704.     {
  705.         $this->isTva = $isTva;
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, CancelEventApplication>
  712.      */
  713.     public function getCancelEventApplications(): Collection
  714.     {
  715.         return $this->cancelEventApplications;
  716.     }
  718.     public function addCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  719.     {
  720.         if (!$this->cancelEventApplications->contains($cancelEventApplication)) {
  721.             $this->cancelEventApplications[] = $cancelEventApplication;
  722.             $cancelEventApplication->setSpecialist($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeCancelEventApplication(CancelEventApplication $cancelEventApplication): self
  729.     {
  730.         if ($this->cancelEventApplications->removeElement($cancelEventApplication)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($cancelEventApplication->getSpecialist() === $this) {
  733.                 $cancelEventApplication->setSpecialist(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     public function getIsVirtualEvent(): ?bool
  741.     {
  742.         return $this->isVirtualEvent;
  743.     }
  745.     public function setIsVirtualEvent(bool $isVirtualEvent): self
  746.     {
  747.         $this->isVirtualEvent = $isVirtualEvent;
  749.         return $this;
  750.     }
  752.     public function getStatus(): ?string
  753.     {
  754.         return $this->status;
  755.     }
  757.     public function setStatus(?string $status): self
  758.     {
  759.         $this->status = $status;
  761.         return $this;
  762.     }
  764.     public function getStatusDate(): ?\DateTimeInterface
  765.     {
  766.         return $this->statusDate;
  767.     }
  769.     public function setStatusDate(?\DateTimeInterface $statusDate): self
  770.     {
  771.         $this->statusDate = $statusDate;
  772.         return $this;
  773.     }
  775.     public function getIdentityCard(): ?string
  776.     {
  777.         return $this->identityCard;
  778.     }
  780.     /**
  781.      * @return File|null
  782.      */
  783.     public function getIdentityCardFile(): ?File
  784.     {
  785.         return $this->identityCardFile;
  786.     }
  788.     public function setIdentityCard(?string $identityCard): self
  789.     {
  790.         $this->identityCard = $identityCard;
  792.         return $this;
  793.     }
  795.     /**
  796.      * @param File|null $identityCardFile
  797.      * @return Specialist
  798.      */
  799.     public function setIdentityCardFile(?File $identityCardFile = null): Specialist
  800.     {
  801.         $this->identityCardFile = $identityCardFile;
  803.         if ($identityCardFile) {
  804.             // if 'updatedAt' is not defined in your entity, use another property
  805.             $this->updatedAt = new DateTime('now');
  806.         }
  807.         return $this;
  808.     }
  810.     public function getInsurance(): ?string
  811.     {
  812.         return $this->insurance;
  813.     }
  815.     /**
  816.      * @return File|null
  817.      */
  818.     public function getInsuranceFile(): ?File
  819.     {
  820.         return $this->insuranceFile;
  821.     }
  823.     public function setInsurance(?string $insurance): self
  824.     {
  825.         $this->insurance = $insurance;
  827.         return $this;
  828.     }
  830.     /**
  831.      * @param File|null $insuranceFile
  832.      * @return Specialist
  833.      */
  834.     public function setInsuranceFile(?File $insuranceFile = null): Specialist
  835.     {
  836.         $this->insuranceFile = $insuranceFile;
  838.         if ($insuranceFile) {
  839.             // if 'updatedAt' is not defined in your entity, use another property
  840.             $this->updatedAt = new DateTime('now');
  841.         }
  842.         return $this;
  843.     }
  845.     public function getDegree(): ?string
  846.     {
  847.         return $this->degree;
  848.     }
  850.     /**
  851.      * @return File|null
  852.      */
  853.     public function getDegreeFile(): ?File
  854.     {
  855.         return $this->degreeFile;
  856.     }
  858.     public function setDegree(?string $degree): self
  859.     {
  860.         $this->degree = $degree;
  862.         return $this;
  863.     }
  865.     /**
  866.      * @param File|null $degreeFile
  867.      * @return Specialist
  868.      */
  869.     public function setDegreeFile(?File $degreeFile = null): Specialist
  870.     {
  871.         $this->degreeFile = $degreeFile;
  873.         if ($degreeFile) {
  874.             // if 'updatedAt' is not defined in your entity, use another property
  875.             $this->updatedAt = new DateTime('now');
  876.         }
  877.         return $this;
  878.     }
  880.     public function getRib(): ?string
  881.     {
  882.         return $this->rib;
  883.     }
  885.     /**
  886.      * @return File|null
  887.      */
  888.     public function getRibFile(): ?File
  889.     {
  890.         return $this->ribFile;
  891.     }
  893.     public function setRib(?string $rib): self
  894.     {
  895.         $this->rib = $rib;
  897.         return $this;
  898.     }
  900.     /**
  901.      * @param File|null $ribFile
  902.      * @return Specialist
  903.      */
  904.     public function setRibFile(?File $ribFile = null): Specialist
  905.     {
  906.         $this->ribFile = $ribFile;
  908.         if ($ribFile) {
  909.             // if 'updatedAt' is not defined in your entity, use another property
  910.             $this->updatedAt = new DateTime('now');
  911.         }
  912.         return $this;
  913.     }
  915.     /**
  916.      * @return Collection<int, VisioEvent>
  917.      */
  918.     public function getVisioEvents(): Collection
  919.     {
  920.         return $this->visioEvents;
  921.     }
  923.     public function addVisioEvent(VisioEvent $visioEvent): self
  924.     {
  925.         if (!$this->visioEvents->contains($visioEvent)) {
  926.             $this->visioEvents[] = $visioEvent;
  927.             $visioEvent->setSpecialist($this);
  928.         }
  930.         return $this;
  931.     }
  933.     public function removeVisioEvent(VisioEvent $visioEvent): self
  934.     {
  935.         if ($this->visioEvents->removeElement($visioEvent)) {
  936.             // set the owning side to null (unless already changed)
  937.             if ($visioEvent->getSpecialist() === $this) {
  938.                 $visioEvent->setSpecialist(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  944.     
  945.     public function getStatusMessage(): ?string
  946.     {
  947.         return $this->statusMessage;
  948.     }
  950.     public function setStatusMessage(?string $statusMessage): self
  951.     {
  952.         $this->statusMessage = $statusMessage;
  954.         return $this;
  955.     }
  956.     /**
  957.      * @return VisioEvent[]
  958.      */
  959.     public function dayVisios(?DateTime $dateTime = null, int $max = 5): array
  960.     {
  961.         $result = [];
  962.         if ($dateTime instanceof DateTime) {
  963.             $today = $dateTime->format('Y-m-d');
  964.         } else {
  965.             $today = (new DateTime())->format('Y-m-d');
  966.         }
  967.         foreach ($this->getVisioEvents() as $visioEvent) {
  968.             if ($visioEvent->getStart()->format('Y-m-d') == $today &&
  969.             count($result) < $max && $visioEvent->getStart() > new DateTime()) {
  970.                 $result[] = $visioEvent;
  971.             }
  972.         }
  973.         return $result;
  974.     }
  975.     /**
  976.      * @return VisioEvent[]
  977.      */
  978.     public function dayVisiosFiltered(?DateTime $dateTime = null, int $max = 5, bool $valid = false): array
  979.     {
  980.         $result = [];
  981.         if ($dateTime instanceof DateTime) {
  982.             $today = $dateTime->format('Y-m-d');
  983.         } else {
  984.             $today = (new DateTime())->format('Y-m-d');
  985.         }
  986.         foreach ($this->getVisioEvents() as $visioEvent) {
  987.             if ($visioEvent->getStart()->format('Y-m-d') == $today &&
  988.                 count($result) < $max && (!$valid || $visioEvent->isOpen())) {
  989.                 $result[] = $visioEvent;
  990.             }
  991.         }
  992.         return $result;
  993.     }
  995.     /**
  996.      * @param DateTime|null $dateTime
  997.      * @param int $max
  998.      * @param bool $valid
  999.      * @param int $rank
  1000.      * @return VisioEvent[]
  1001.      */
  1002.     public function dayVisiosNextDay(?DateTime $dateTime = null, int $max = 5, bool $valid = false, int $rank = 0): array
  1003.     {
  1004.         if ($dateTime == null){
  1005.             $dateTime = new DateTime();
  1006.         }
  1007.         $result = $this->dayVisiosFiltered($dateTime, $max, $valid);
  1008.         if (empty($result) && $rank < 10){
  1009.             $dateTime->modify('+1 day');
  1010.             $result = $this->dayVisiosNextDay($dateTime, $max, $valid, ++$rank);
  1011.         }
  1012.         return $result;
  1013.     }
  1015.     /**
  1016.      * @return Collection<int, VisioEventPromotion>
  1017.      */
  1018.     public function getVisioEventPromotions(): Collection
  1019.     {
  1020.         return $this->visioEventPromotions;
  1021.     }
  1023.     public function addVisioEventPromotion(VisioEventPromotion $visioEventPromotion): self
  1024.     {
  1025.         if (!$this->visioEventPromotions->contains($visioEventPromotion)) {
  1026.             $this->visioEventPromotions[] = $visioEventPromotion;
  1027.             $visioEventPromotion->addSpecialist($this);
  1028.         }
  1030.         return $this;
  1031.     }
  1032.     
  1034.     public function removeVisioEventPromotion(VisioEventPromotion $visioEventPromotion): self
  1035.     {
  1036.         if ($this->visioEventPromotions->removeElement($visioEventPromotion)) {
  1037.             $visioEventPromotion->removeSpecialist($this);
  1038.         }
  1040.         return $this;
  1041.     }
  1043.     /**
  1044.      * @Groups({"search"})
  1045.      * @SerializedName("text")
  1046.      * @return string
  1047.      */
  1048.     public function getText(): string
  1049.     {
  1050.         return (string)$this;
  1051.     }
  1053.     public function getUuid()
  1054.     {
  1055.         return $this->uuid;
  1056.     }
  1058.     public function setUuid($uuid): self
  1059.     {
  1060.         $this->uuid = $uuid;
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * @return bool
  1067.      * @var Datetime $start
  1068.      * @var Datetime $end
  1069.      * Permet de savoir si il est disponible en fonction d'une date de début et de fin
  1070.      */
  1071.     public function isAvailable(\DateTime $start, \DateTime $end): bool
  1072.     {
  1073.         $isAvailable = true;
  1074.         foreach($this->getEvents()->toArray() as $event)
  1075.         {
  1076.             if($event->isInComing()) {
  1077.                 if($event->getStart() >= $start && $event->getStart() <= $end
  1078.                     && $event->getEnd() >= $start && $event->getEnd() <= $end) {
  1079.                         $isAvailable = false;
  1080.                 }
  1081.             }
  1082.         }
  1083.         return $isAvailable;
  1084.     }
  1086.     public function getIsAffiliated(): ?bool
  1087.     {
  1088.         return $this->isAffiliated;
  1089.     }
  1091.     public function setIsAffiliated(?bool $isAffiliated): self
  1092.     {
  1093.         $this->isAffiliated = $isAffiliated;
  1095.         return $this;
  1096.     }
  1098.     public function getAffiliatedCompany(): ?Company
  1099.     {
  1100.         return $this->affiliatedCompany;
  1101.     }
  1103.     public function setAffiliatedCompany(?Company $affiliatedCompany): self
  1104.     {
  1105.         $this->affiliatedCompany = $affiliatedCompany;
  1107.         return $this;
  1108.     }
  1110.     /**
  1111.      * @return Collection<int, Company>
  1112.      */
  1113.     public function getCompanies(): Collection
  1114.     {
  1115.         return $this->companies;
  1116.     }
  1118.     public function setCompanies(Collection $companies): self
  1119.     {
  1120.         $this->companies = $companies;
  1121.         return $this;
  1122.     }
  1124.     public function addCompany(Company $company): self
  1125.     {
  1126.         if (!$this->companies->contains($company)) {
  1127.             $this->companies[] = $company;
  1128.         }
  1130.         return $this;
  1131.     }
  1133.     public function removeCompany(Company $company): self
  1134.     {
  1135.         $this->companies->removeElement($company);
  1137.         return $this;
  1138.     }
  1140.     public function getspecialistType(): ?string
  1141.     {
  1142.        
  1143.        
  1144.         return $this->specialistType;
  1145.     }
  1147.     public function setspecialistType(?string $specialistType): self
  1148.     {
  1149.         $this->specialistType = $specialistType;
  1151.         return $this;
  1152.     }
  1154.     /**
  1155.      * @return Collection<int, AffiliatedEventApplication>
  1156.      */
  1157.     public function getAffiliatedEventApplications(): Collection
  1158.     {
  1159.         return $this->affiliatedEventApplications;
  1160.     }
  1162.     public function addAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1163.     {
  1164.         if (!$this->affiliatedEventApplications->contains($affiliatedEventApplication)) {
  1165.             $this->affiliatedEventApplications[] = $affiliatedEventApplication;
  1166.             $affiliatedEventApplication->setSpecialist($this);
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     public function removeAffiliatedEventApplication(AffiliatedEventApplication $affiliatedEventApplication): self
  1173.     {
  1174.         if ($this->affiliatedEventApplications->removeElement($affiliatedEventApplication)) {
  1175.             // set the owning side to null (unless already changed)
  1176.             if ($affiliatedEventApplication->getSpecialist() === $this) {
  1177.                 $affiliatedEventApplication->setSpecialist(null);
  1178.             }
  1179.         }
  1181.         return $this;
  1182.     }
  1184.     public function getSiret(): ?string
  1185.     {
  1186.         return $this->siret;
  1187.     }
  1189.     public function setSiret(?string $siret): self
  1190.     {
  1191.         $this->siret = $siret;
  1193.         return $this;
  1194.     }
  1195.    
  1196. }