src/Entity/User.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[UniqueEntity('phone', message: 'Le numéro de téléphone est déjà utilisé')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     private ?int $id = null;
  23.     #[ORM\Column(length: 180, unique: true)]
  24.     private ?string $phone = null;
  26.     #[ORM\Column]
  27.     private ?array $roles = [];
  29.     /**
  30.      * @var string|null The hashed password
  31.      */
  32.     #[ORM\Column(nullable: true)]
  33.     private ?string $password = null;
  35.     #[ORM\Column(length: 255)]
  36.     private ?string $firstname = null;
  38.     #[ORM\Column(length: 255)]
  39.     private ?string $lastname = null;
  41.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  42.     private ?\DateTimeInterface $birthday = null;
  44.     #[ORM\Column(length: 255, nullable: true)]
  45.     private ?string $adress = null;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     private ?string $adressBis = null;
  50.     #[ORM\Column(nullable: true)]
  51.     private ?int $zipcode = null;
  53.     #[ORM\Column(length: 255, nullable: true)]
  54.     private ?string $city = null;
  56.     #[ORM\Column(length: 255)]
  57.     private ?string $email = null;
  59.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  60.     private ?\DateTimeInterface $created_at = null;
  62.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  63.     private ?\DateTimeInterface $edited_at = null;
  65.     #[ORM\Column(nullable: true)]
  66.     private ?bool $handicapped = false;
  68.     #[ORM\Column(length: 1024, nullable: true)]
  69.     private ?string $reset_token = null;
  71.     #[ORM\Column]
  72.     private ?bool $enabled = false;
  74.     #[ORM\Column(nullable: true)]
  75.     private ?int $admission = null;
  77.     #[ORM\Column(length: 1, nullable: true)]
  78.     private ?string $ranking = null;
  80.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  81.     private ?string $situation = null;
  83.     #[ORM\Column]
  84.     private ?bool $drivinglicence = false;
  86.     #[ORM\Column(length: 255, nullable: true)]
  87.     private ?string $rgpd = null;
  89.     #[ORM\Column]
  90.     private ?bool $hasCompany = false;
  92.     #[ORM\Column(type:'string', length: 255, nullable: true)]
  93.     private ?string $countryCode = null;
  95.     #[ORM\Column(length: 255, nullable: true)]
  96.     private ?string $verificationCode = null;
  98.     #[ORM\Column]
  99.     private ?bool $verified = false;
  101.     #[ORM\ManyToOne(inversedBy: 'User')]
  102.     private ?Progress $progress = null;
  104.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: Attachments::class)]
  105.     private Collection $attachments;
  107.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LogUser::class)]
  108.     private Collection $logUsers;
  110.     #[ORM\Column(nullable: true)]
  111.     private ?bool $parcourssup = false;
  113.     #[ORM\ManyToOne(inversedBy: 'users')]
  114.     private ?Training $training = null;
  117.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: MCQResult::class)]
  118.     private Collection $mCQResults;
  120.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Score::class)]
  121.     private Collection $scores;
  123.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: StudentResponse::class)]
  124.     private Collection $studentResponses;
  126.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LogAttachments::class)]
  127.     private Collection $logAttachments;
  129.     #[ORM\Column(nullable: true)]
  130.     private ?bool $validatedPj = false;
  132.     #[ORM\Column(nullable: true)]
  133.     private ?bool $mCQValid = false;
  135.     #[ORM\ManyToOne(inversedBy: 'users')]
  136.     private ?AdmissionCategory $admissionCategory = null;
  138.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commitment::class)]
  139.     private Collection $commitments;
  141.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Application::class)]
  142.     private Collection $applications;
  144.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: MCQQuestionsStorage::class)]
  145.     private Collection $mcqQuestionsStorages;
  147.     #[ORM\ManyToMany(targetEntity: Appointment::class, mappedBy: 'user')]
  148.     private Collection $appointments;
  150.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AppointmentsCheck::class)]
  151.     private Collection $appointmentsChecks;
  153.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: BookCv::class)]
  154.     private Collection $bookCvs;
  156.     #[ORM\Column(nullable: true)]
  157.     private ?bool $waitCommitment = false;
  159.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: HistoryUser::class)]
  160.     private Collection $historyUsers;
  162.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AcapellaDemand::class)]
  163.     private Collection $acapellaDemands;
  165.     #[ORM\Column(nullable: true)]
  166.     private ?bool $commimtmentInfo = false;
  168.     #[ORM\OrderBy(['createdAt' => 'DESC'])]
  169.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserComment::class)]
  170.     private Collection $userComments;
  172.     #[ORM\Column(nullable: true)]
  173.     private ?string $id_ypareo = null;
  175.     #[ORM\Column]
  176.     private ?bool $poursuite = false;
  178.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: ComplementaryPj::class)]
  179.     private Collection $complementaryPjs;
  181.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AttachmentsAf::class)]
  182.     private Collection $attachmentsAfs;
  184.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: LegalRepresentative::class)]
  185.     private Collection $legalRepresentatives;
  187.     #[ORM\Column(length: 255, nullable: true)]
  188.     private ?string $lastSchoolName = null;
  190.     #[ORM\Column(length: 255, nullable: true)]
  191.     private ?string $brevoId = null;
  193.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LogSms::class)]
  194.     private Collection $sms;
  195.     public function __construct()
  196.     {
  197.         $this->attachments = new ArrayCollection();
  198.         $this->logUsers = new ArrayCollection();
  200.         $this->mCQResults = new ArrayCollection();
  201.         $this->scores = new ArrayCollection();
  202.         $this->studentResponses = new ArrayCollection();
  203.         $this->logAttachments = new ArrayCollection();
  204.         $this->commitments = new ArrayCollection();
  205.         $this->applications = new ArrayCollection();
  206.         $this->mcqQuestionsStorages = new ArrayCollection();
  207.         $this->appointments = new ArrayCollection();
  208.         $this->appointmentsChecks = new ArrayCollection();
  209.         $this->bookCvs = new ArrayCollection();
  210.         $this->historyUsers = new ArrayCollection();
  211.         $this->acapellaDemands = new ArrayCollection();
  212.         $this->userComments = new ArrayCollection();
  213.         $this->complementaryPjs = new ArrayCollection();
  214.         $this->attachmentsAfs = new ArrayCollection();
  215.         $this->legalRepresentatives = new ArrayCollection();
  216.         $this->sms = new ArrayCollection();
  217.     }
  219.     public function getId(): ?int
  220.     {
  221.         return $this->id;
  222.     }
  224.     public function getPhone(): ?string
  225.     {
  226.         return $this->phone;
  227.     }
  229.     public function setPhone(string $phone): self
  230.     {
  231.         $this->phone = $phone;
  233.         return $this;
  234.     }
  236.     /**
  237.      * A visual identifier that represents this user.
  238.      *
  239.      * @see UserInterface
  240.      */
  241.     public function getUserIdentifier(): string
  242.     {
  243.         return (string) $this->phone;
  244.     }
  246.     /**
  247.      * @see UserInterface
  248.      */
  249.     public function getRoles(): array
  250.     {
  251.         $roles = $this->roles;
  252.         // guarantee every user at least has ROLE_USER
  253.         $roles[] = 'ROLE_USER';
  255.         return array_unique($roles);
  256.     }
  258.     public function setRoles(array $roles): self
  259.     {
  260.         $this->roles = $roles;
  262.         return $this;
  263.     }
  265.     /**
  266.      * @see PasswordAuthenticatedUserInterface
  267.      */
  268.     public function getPassword(): string
  269.     {
  270.         return $this->password;
  271.     }
  273.     public function setPassword(string $password): self
  274.     {
  275.         $this->password = $password;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @see UserInterface
  282.      */
  283.     public function eraseCredentials()
  284.     {
  285.         // If you store any temporary, sensitive data on the user, clear it here
  286.         // $this->plainPassword = null;
  287.     }
  289.     public function getFirstname(): ?string
  290.     {
  291.         return $this->firstname;
  292.     }
  294.     public function setFirstname(string $firstname): self
  295.     {
  296.         $this->firstname = $firstname;
  298.         return $this;
  299.     }
  301.     public function getLastname(): ?string
  302.     {
  303.         return $this->lastname;
  304.     }
  306.     public function setLastname(string $lastname): self
  307.     {
  308.         $this->lastname = $lastname;
  310.         return $this;
  311.     }
  313.     public function getBirthday(): ?\DateTimeInterface
  314.     {
  315.         return $this->birthday;
  316.     }
  318.     public function setBirthday(?\DateTimeInterface $birthday): self
  319.     {
  320.         $this->birthday = $birthday;
  322.         return $this;
  323.     }
  325.     public function getAdress(): ?string
  326.     {
  327.         return $this->adress;
  328.     }
  330.     public function setAdress(string $adress): self
  331.     {
  332.         $this->adress = $adress;
  334.         return $this;
  335.     }
  337.     public function getAdressBis(): ?string
  338.     {
  339.         return $this->adressBis;
  340.     }
  342.     public function setAdressBis(string $adressBis): self
  343.     {
  344.         $this->adressBis = $adressBis;
  346.         return $this;
  347.     }
  349.     public function getZipcode(): ?int
  350.     {
  351.         return $this->zipcode;
  352.     }
  354.     public function setZipcode(int $zipcode): self
  355.     {
  356.         $this->zipcode = $zipcode;
  358.         return $this;
  359.     }
  361.     public function getCity(): ?string
  362.     {
  363.         return $this->city;
  364.     }
  366.     public function setCity(string $city): self
  367.     {
  368.         $this->city = $city;
  370.         return $this;
  371.     }
  373.     public function getEmail(): ?string
  374.     {
  375.         return $this->email;
  376.     }
  378.     public function setEmail(string $email): self
  379.     {
  380.         $this->email = $email;
  382.         return $this;
  383.     }
  385.     public function getCreatedAt(): ?\DateTimeInterface
  386.     {
  387.         return $this->created_at;
  388.     }
  390.     public function setCreatedAt(\DateTimeInterface $created_at): self
  391.     {
  392.         $this->created_at = $created_at;
  394.         return $this;
  395.     }
  397.     public function getEditedAt(): ?\DateTimeInterface
  398.     {
  399.         return $this->edited_at;
  400.     }
  402.     public function setEditedAt(\DateTimeInterface $edited_at): self
  403.     {
  404.         $this->edited_at = $edited_at;
  406.         return $this;
  407.     }
  409.     public function isHandicapped(): ?bool
  410.     {
  411.         return $this->handicapped;
  412.     }
  414.     public function setHandicapped(bool $handicapped): self
  415.     {
  416.         $this->handicapped = $handicapped;
  418.         return $this;
  419.     }
  421.     public function getResetToken(): ?string
  422.     {
  423.         return $this->reset_token;
  424.     }
  426.     public function setResetToken(string $reset_token): self
  427.     {
  428.         $this->reset_token = $reset_token;
  430.         return $this;
  431.     }
  433.     public function isEnabled(): ?bool
  434.     {
  435.         return $this->enabled;
  436.     }
  438.     public function setEnabled(bool $enabled): self
  439.     {
  440.         $this->enabled = $enabled;
  442.         return $this;
  443.     }
  445.     public function getAdmission(): ?int
  446.     {
  447.         return $this->admission;
  448.     }
  450.     public function setAdmission(int $admission): self
  451.     {
  452.         $this->admission = $admission;
  454.         return $this;
  455.     }
  457.     public function getRanking(): ?string
  458.     {
  459.         return $this->ranking;
  460.     }
  462.     public function setRanking(string $ranking): self
  463.     {
  464.         $this->ranking = $ranking;
  466.         return $this;
  467.     }
  469.     public function getSituation(): ?string
  470.     {
  471.         return $this->situation;
  472.     }
  474.     public function setSituation(string $situation): self
  475.     {
  476.         $this->situation = $situation;
  478.         return $this;
  479.     }
  481.     public function isDrivinglicence(): ?bool
  482.     {
  483.         return $this->drivinglicence;
  484.     }
  486.     public function setDrivinglicence(bool $drivinglicence): self
  487.     {
  488.         $this->drivinglicence = $drivinglicence;
  490.         return $this;
  491.     }
  493.     public function getRgpd(): ?string
  494.     {
  495.         return $this->rgpd;
  496.     }
  498.     public function setRgpd(?string $rgpd): self
  499.     {
  500.         $this->rgpd = $rgpd;
  502.         return $this;
  503.     }
  505.     public function isHasCompany(): ?bool
  506.     {
  507.         return $this->hasCompany;
  508.     }
  510.     public function setHasCompany(bool $hasCompany): self
  511.     {
  512.         $this->hasCompany = $hasCompany;
  514.         return $this;
  515.     }
  516.     public function getCountryCode(): ?string
  517.     {
  518.         return $this->countryCode;
  519.     }
  521.     public function setCountryCode(string $countryCode): self
  522.     {
  523.         $this->countryCode = $countryCode;
  525.         return $this;
  526.     }
  528.     public function getVerificationCode(): ?string
  529.     {
  530.         return $this->verificationCode;
  531.     }
  533.     public function setVerificationCode(?string $verificationCode): self
  534.     {
  535.         $this->verificationCode = $verificationCode;
  537.         return $this;
  538.     }
  540.     public function getVerified(): ?bool
  541.     {
  542.         return $this->verified;
  543.     }
  545.     public function setVerified(bool $verified): self
  546.     {
  547.         $this->verified = $verified;
  549.         return $this;
  550.     }
  552.     public function getProgress(): ?Progress
  553.     {
  554.         return $this->progress;
  555.     }
  557.     public function setProgress(?Progress $progress): self
  558.     {
  559.         $this->progress = $progress;
  561.         return $this;
  562.     }
  564.     /**
  565.      * @return Collection<int, Attachments>
  566.      */
  567.     public function getAttachments(): Collection
  568.     {
  569.         return $this->attachments;
  570.     }
  572.     public function addAttachment(Attachments $attachment): self
  573.     {
  574.         if (!$this->attachments->contains($attachment)) {
  575.             $this->attachments->add($attachment);
  576.             $attachment->setUser($this);
  577.         }
  579.         return $this;
  580.     }
  582.     public function removeAttachment(Attachments $attachment): self
  583.     {
  584.         if ($this->attachments->removeElement($attachment)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($attachment->getUser() === $this) {
  587.                 $attachment->setUser(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection<int, LogUser>
  596.      */
  597.     public function getLogUsers(): Collection
  598.     {
  599.         return $this->logUsers;
  600.     }
  602.     public function addLogUser(LogUser $logUser): self
  603.     {
  604.         if (!$this->logUsers->contains($logUser)) {
  605.             $this->logUsers->add($logUser);
  606.             $logUser->setUser($this);
  607.         }
  609.         return $this;
  610.     }
  612.     public function removeLogUser(LogUser $logUser): self
  613.     {
  614.         if ($this->logUsers->removeElement($logUser)) {
  615.             // set the owning side to null (unless already changed)
  616.             if ($logUser->getUser() === $this) {
  617.                 $logUser->setUser(null);
  618.             }
  619.         }
  621.         return $this;
  622.     }
  624.     public function isParcourssup(): ?bool
  625.     {
  626.         return $this->parcourssup;
  627.     }
  629.     public function setParcourssup(bool $parcourssup): self
  630.     {
  631.         $this->parcourssup = $parcourssup;
  633.         return $this;
  634.     }
  636.     public function getTraining(): ?Training
  637.     {
  638.         return $this->training;
  639.     }
  641.     public function setTraining(?Training $training): self
  642.     {
  643.         $this->training = $training;
  645.         return $this;
  646.     }
  648.     /**
  649.      * @return Collection<int, MCQResult>
  650.      */
  651.     public function getMCQResults(): Collection
  652.     {
  653.         return $this->mCQResults;
  654.     }
  656.     public function addMCQResult(MCQResult $mCQResult): self
  657.     {
  658.         if (!$this->mCQResults->contains($mCQResult)) {
  659.             $this->mCQResults->add($mCQResult);
  660.             $mCQResult->setUser($this);
  661.         }
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection<int, MCQQuestionsStorage>
  667.      */
  668.     public function getMcqQuestionsStorages(): Collection
  669.     {
  670.         return $this->mcqQuestionsStorages;
  671.     }
  673.     public function addMcqQuestionsStorages(MCQQuestionsStorage $mcqQuestionsStorages): self
  674.     {
  675.         if (!$this->mcqQuestionsStorages->contains($mcqQuestionsStorages)) {
  676.             $this->mcqQuestionsStorages->add($mcqQuestionsStorages);
  677.             $mcqQuestionsStorages->setUser($this);
  678.         }
  680.         return $this;
  681.     }
  684.     public function removeMCQResult(MCQResult $mCQResult): self
  685.     {
  686.         if ($this->mCQResults->removeElement($mCQResult)) {
  687.             // set the owning side to null (unless already changed)
  688.             if ($mCQResult->getUser() === $this) {
  689.                 $mCQResult->setUser(null);
  690.             }
  691.         }
  692.             return $this;
  693.     }
  696.     public function removeMcqQuestionsStorages(MCQQuestionsStorage $mcqQuestionsStorages): self
  697.     {
  698.         if ($this->mcqQuestionsStorages->removeElement($mcqQuestionsStorages)) {
  699.             // set the owning side to null (unless already changed)
  700.             if ($mcqQuestionsStorages->getUser() === $this) {
  701.                 $mcqQuestionsStorages->setUser(null);
  702.             }
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection<int, Score>
  710.      */
  711.     public function getScores(): Collection
  712.     {
  713.         return $this->scores;
  714.     }
  716.     public function addScore(Score $score): self
  717.     {
  718.         if (!$this->scores->contains($score)) {
  719.             $this->scores->add($score);
  720.             $score->setUser($this);
  721.         }
  723.         return $this;
  724.     }
  726.     public function removeScore(Score $score): self
  727.     {
  728.         if ($this->scores->removeElement($score)) {
  729.             // set the owning side to null (unless already changed)
  730.             if ($score->getUser() === $this) {
  731.                 $score->setUser(null);
  732.             }
  733.         }
  735.         return $this;
  736.     }
  738.     /**
  739.      * @return Collection<int, StudentResponse>
  740.      */
  741.     public function getStudentResponses(): Collection
  742.     {
  743.         return $this->studentResponses;
  744.     }
  746.     public function addStudentResponse(StudentResponse $studentResponse): self
  747.     {
  748.         if (!$this->studentResponses->contains($studentResponse)) {
  749.             $this->studentResponses->add($studentResponse);
  750.             $studentResponse->setUser($this);
  751.         }
  753.         return $this;
  754.     }
  756.     public function removeStudentResponse(StudentResponse $studentResponse): self
  757.     {
  758.         if ($this->studentResponses->removeElement($studentResponse)) {
  759.             // set the owning side to null (unless already changed)
  760.             if ($studentResponse->getUser() === $this) {
  761.                 $studentResponse->setUser(null);
  762.             }
  763.         }
  765.         return $this;
  766.     }
  768.     /**
  769.      * @return Collection<int, LogAttachments>
  770.      */
  771.     public function getLogAttachments(): Collection
  772.     {
  773.         return $this->logAttachments;
  774.     }
  776.     public function addLogAttachment(LogAttachments $logAttachment): self
  777.     {
  778.         if (!$this->logAttachments->contains($logAttachment)) {
  779.             $this->logAttachments->add($logAttachment);
  780.             $logAttachment->setUser($this);
  781.         }
  783.         return $this;
  784.     }
  786.     public function removeLogAttachment(LogAttachments $logAttachment): self
  787.     {
  788.         if ($this->logAttachments->removeElement($logAttachment)) {
  789.             // set the owning side to null (unless already changed)
  790.             if ($logAttachment->getUser() === $this) {
  791.                 $logAttachment->setUser(null);
  792.             }
  793.         }
  795.         return $this;
  796.     }
  798.     public function isValidatedPj(): ?bool
  799.     {
  800.         return $this->validatedPj;
  801.     }
  803.     public function setValidatedPj(bool $validatedPj): self
  804.     {
  805.         $this->validatedPj = $validatedPj;
  807.         return $this;
  808.     }
  810.     public function isMCQValid(): ?bool
  811.     {
  812.         return $this->mCQValid;
  813.     }
  815.     public function setMCQValid(?bool $mCQValid): self
  816.     {
  817.         $this->mCQValid = $mCQValid;
  819.         return $this;
  820.     }
  822.     public function getAdmissionCategory(): ?AdmissionCategory
  823.     {
  824.         return $this->admissionCategory;
  825.     }
  827.     public function setAdmissionCategory(?AdmissionCategory $admissionCategory): self
  828.     {
  829.         $this->admissionCategory = $admissionCategory;
  831.         return $this;
  832.     }
  834.     /**
  835.      * @return Collection<int, Commitment>
  836.      */
  837.     public function getCommitments(): Collection
  838.     {
  839.         return $this->commitments;
  840.     }
  842.     public function addCommitment(Commitment $commitment): self
  843.     {
  844.         if (!$this->commitments->contains($commitment)) {
  845.             $this->commitments->add($commitment);
  846.             $commitment->setUser($this);
  847.         }
  849.         return $this;
  850.     }
  852.     public function removeCommitment(Commitment $commitment): self
  853.     {
  854.         if ($this->commitments->removeElement($commitment)) {
  855.             // set the owning side to null (unless already changed)
  856.             if ($commitment->getUser() === $this) {
  857.                 $commitment->setUser(null);
  858.             }
  859.         }
  861.         return $this;
  862.     }
  864.     /**
  865.      * @return Collection<int, Application>
  866.      */
  867.     public function getApplications(): Collection
  868.     {
  869.         return $this->applications;
  870.     }
  872.     public function addApplication(Application $application): self
  873.     {
  874.         if (!$this->applications->contains($application)) {
  875.             $this->applications->add($application);
  876.             $application->setUser($this);
  877.         }
  879.         return $this;
  880.     }
  882.     public function removeApplication(Application $application): self
  883.     {
  884.         if ($this->applications->removeElement($application)) {
  885.             // set the owning side to null (unless already changed)
  886.             if ($application->getUser() === $this) {
  887.                 $application->setUser(null);
  888.             }
  889.         }
  891.         return $this;
  892.     }
  894.     /**
  895.      * @return Collection<int, Appointment>
  896.      */
  897.     public function getAppointments(): Collection
  898.     {
  899.         return $this->appointments;
  900.     }
  902.     public function addAppointment(Appointment $appointment): self
  903.     {
  904.         if (!$this->appointments->contains($appointment)) {
  905.             $this->appointments->add($appointment);
  906.             $appointment->addUser($this);
  907.         }
  909.         return $this;
  910.     }
  912.     public function removeAppointment(Appointment $appointment): self
  913.     {
  914.         if ($this->appointments->removeElement($appointment)) {
  915.             $appointment->removeUser($this);
  916.         }
  918.         return $this;
  919.     }
  921.     /**
  922.      * @return Collection<int, AppointmentsCheck>
  923.      */
  924.     public function getAppointmentsChecks(): Collection
  925.     {
  926.         return $this->appointmentsChecks;
  927.     }
  929.     public function addAppointmentsChecks(AppointmentsCheck $appointmentsCheck): self
  930.     {
  931.         if (!$this->appointmentsChecks->contains($appointmentsCheck)) {
  932.             $this->appointmentsChecks->add($appointmentsCheck);
  933.             $appointmentsCheck->setUser($this);
  934.         }
  936.         return $this;
  937.     }
  939.     public function removeAppointmentsChecks(AppointmentsCheck $appointmentsCheck): self
  940.     {
  941.         if ($this->appointmentsChecks->removeElement($appointmentsCheck)) {
  942.             // set the owning side to null (unless already changed)
  943.             if ($appointmentsCheck->getUser() === $this) {
  944.                 $appointmentsCheck->setUser(null);
  945.             }
  946.         }
  948.         return $this;
  949.     }
  951.     /**
  952.      * @return Collection<int, BookCv>
  953.      */
  954.     public function getBookCvs(): Collection
  955.     {
  956.         return $this->bookCvs;
  957.     }
  959.     public function addBookCv(BookCv $bookCv): self
  960.     {
  961.         if (!$this->bookCvs->contains($bookCv)) {
  962.             $this->bookCvs->add($bookCv);
  963.             $bookCv->setUser($this);
  964.         }
  966.         return $this;
  967.     }
  969.     public function removeBookCv(BookCv $bookCv): self
  970.     {
  971.         if ($this->bookCvs->removeElement($bookCv)) {
  972.             // set the owning side to null (unless already changed)
  973.             if ($bookCv->getUser() === $this) {
  974.                 $bookCv->setUser(null);
  975.             }
  976.         }
  978.         return $this;
  979.     }
  981.     public function isWaitCommitment(): ?bool
  982.     {
  983.         return $this->waitCommitment;
  984.     }
  986.     public function setWaitCommitment(?bool $waitCommitment): self
  987.     {
  988.         $this->waitCommitment = $waitCommitment;
  990.         return $this;
  991.     }
  993.     /**
  994.      * @return Collection<int, HistoryUser>
  995.      */
  996.     public function getHistoryUsers(): Collection
  997.     {
  998.         return $this->historyUsers;
  999.     }
  1001.     public function addHistoryUser(HistoryUser $historyUser): self
  1002.     {
  1003.         if (!$this->historyUsers->contains($historyUser)) {
  1004.             $this->historyUsers->add($historyUser);
  1005.             $historyUser->setUser($this);
  1006.         }
  1008.         return $this;
  1009.     }
  1011.     public function removeHistoryUser(HistoryUser $historyUser): self
  1012.     {
  1013.         if ($this->historyUsers->removeElement($historyUser)) {
  1014.             // set the owning side to null (unless already changed)
  1015.             if ($historyUser->getUser() === $this) {
  1016.                 $historyUser->setUser(null);
  1017.             }
  1018.         }
  1020.         return $this;
  1021.     }
  1023.     /**
  1024.      * @return Collection<int, AcapellaDemand>
  1025.      */
  1026.     public function getAcapellaDemands(): Collection
  1027.     {
  1028.         return $this->acapellaDemands;
  1029.     }
  1031.     public function addAcapellaDemand(AcapellaDemand $acapellaDemand): self
  1032.     {
  1033.         if (!$this->acapellaDemands->contains($acapellaDemand)) {
  1034.             $this->acapellaDemands->add($acapellaDemand);
  1035.             $acapellaDemand->setUser($this);
  1036.         }
  1038.         return $this;
  1039.     }
  1041.     public function removeAcapellaDemand(AcapellaDemand $acapellaDemand): self
  1042.     {
  1043.         if ($this->acapellaDemands->removeElement($acapellaDemand)) {
  1044.             // set the owning side to null (unless already changed)
  1045.             if ($acapellaDemand->getUser() === $this) {
  1046.                 $acapellaDemand->setUser(null);
  1047.             }
  1048.         }
  1050.         return $this;
  1051.     }
  1053.     public function isCommimtmentInfo(): ?bool
  1054.     {
  1055.         return $this->commimtmentInfo;
  1056.     }
  1058.     public function setCommimtmentInfo(?bool $commimtmentInfo): self
  1059.     {
  1060.         $this->commimtmentInfo = $commimtmentInfo;
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * @return Collection<int, UserComment>
  1067.      */
  1068.     public function getUserComments(): Collection
  1069.     {
  1070.         return $this->userComments;
  1071.     }
  1073.     public function addUserComment(UserComment $userComment): self
  1074.     {
  1075.         if (!$this->userComments->contains($userComment)) {
  1076.             $this->userComments->add($userComment);
  1077.             $userComment->setUser($this);
  1078.         }
  1080.         return $this;
  1081.     }
  1083.     public function removeUserComment(UserComment $userComment): self
  1084.     {
  1085.         if ($this->userComments->removeElement($userComment)) {
  1086.             // set the owning side to null (unless already changed)
  1087.             if ($userComment->getUser() === $this) {
  1088.                 $userComment->setUser(null);
  1089.             }
  1090.         }
  1092.         return $this;
  1093.     }
  1095.     public function getIdYpareo(): ?string
  1096.     {
  1097.         return $this->id_ypareo;
  1098.     }
  1100.     public function setIdYpareo(?string $id_ypareo): self
  1101.     {
  1102.         $this->id_ypareo = $id_ypareo;
  1104.         return $this;
  1105.     }
  1108.     public function toYpareo(?array $u_ypareo): self
  1109.     {
  1110.         if ($u_ypareo['adresse']['tel2'] != null) {
  1111.             $this->setPhone($u_ypareo['adresse']['tel2']);
  1112.         } else {
  1113.             $this->setPhone($u_ypareo['adresse']['tel1']);
  1114.         }
  1115.         $mystringBirthday = str_replace("/", "-", $u_ypareo['dateNaissanceApprenant']);
  1116.         $newDateString = new \DateTimeImmutable($mystringBirthday);
  1119.         $this->setFirstname($u_ypareo['prenomApprenant']);
  1120.         $this->setLastname($u_ypareo['nomApprenant']);
  1121.         $this->setBirthday($newDateString);
  1122.         $this->setAdress($u_ypareo['adresse']['adr1']);
  1123.         $this->setCity($u_ypareo['adresse']['ville']);
  1124.         $this->setZipcode($u_ypareo['adresse']['cp']);
  1125.         $this->setEmail($u_ypareo['adresse']['email']);
  1126.         $this->setHasCompany(false);
  1127. //        $this->setStep(1);
  1128.         $this->setHandicapped(false);
  1129.         $this->setIdYpareo($u_ypareo['codeApprenant']);
  1131.         return $this;
  1132.     }
  1134.     public function isPoursuite(): ?bool
  1135.     {
  1136.         return $this->poursuite;
  1137.     }
  1139.     public function setPoursuite(bool $poursuite): self
  1140.     {
  1141.         $this->poursuite = $poursuite;
  1143.         return $this;
  1144.     }
  1146.     /**
  1147.      * @return Collection<int, ComplementaryPj>
  1148.      */
  1149.     public function getComplementaryPjs(): Collection
  1150.     {
  1151.         return $this->complementaryPjs;
  1152.     }
  1154.     public function addComplementaryPj(ComplementaryPj $complementaryPj): self
  1155.     {
  1156.         if (!$this->complementaryPjs->contains($complementaryPj)) {
  1157.             $this->complementaryPjs->add($complementaryPj);
  1158.             $complementaryPj->setUser($this);
  1159.         }
  1161.         return $this;
  1162.     }
  1164.     public function removeComplementaryPj(ComplementaryPj $complementaryPj): self
  1165.     {
  1166.         if ($this->complementaryPjs->removeElement($complementaryPj)) {
  1167.             // set the owning side to null (unless already changed)
  1168.             if ($complementaryPj->getUser() === $this) {
  1169.                 $complementaryPj->setUser(null);
  1170.             }
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     /**
  1177.      * @return Collection<int, AttachmentsAf>
  1178.      */
  1179.     public function getAttachmentsAfs(): Collection
  1180.     {
  1181.         return $this->attachmentsAfs;
  1182.     }
  1184.     public function addAttachmentsAf(AttachmentsAf $attachmentsAf): self
  1185.     {
  1186.         if (!$this->attachmentsAfs->contains($attachmentsAf)) {
  1187.             $this->attachmentsAfs->add($attachmentsAf);
  1188.             $attachmentsAf->setUser($this);
  1189.         }
  1191.         return $this;
  1192.     }
  1194.     public function removeAttachmentsAf(AttachmentsAf $attachmentsAf): self
  1195.     {
  1196.         if ($this->attachmentsAfs->removeElement($attachmentsAf)) {
  1197.             // set the owning side to null (unless already changed)
  1198.             if ($attachmentsAf->getUser() === $this) {
  1199.                 $attachmentsAf->setUser(null);
  1200.             }
  1201.         }
  1203.         return $this;
  1204.     }
  1206.     /**
  1207.      * @return Collection<int, LegalRepresentative>
  1208.      */
  1209.     public function getLegalRepresentatives(): Collection
  1210.     {
  1211.         return $this->legalRepresentatives;
  1212.     }
  1214.     public function addLegalRepresentative(LegalRepresentative $legalRepresentative): self
  1215.     {
  1216.         if (!$this->legalRepresentatives->contains($legalRepresentative)) {
  1217.             $this->legalRepresentatives->add($legalRepresentative);
  1218.             $legalRepresentative->setUsers($this);
  1219.         }
  1221.         return $this;
  1222.     }
  1224.     public function removeLegalRepresentative(LegalRepresentative $legalRepresentative): self
  1225.     {
  1226.         if ($this->legalRepresentatives->removeElement($legalRepresentative)) {
  1227.             // set the owning side to null (unless already changed)
  1228.             if ($legalRepresentative->getUsers() === $this) {
  1229.                 $legalRepresentative->setUsers(null);
  1230.             }
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     public function getLastSchoolName(): ?string
  1237.     {
  1238.         return $this->lastSchoolName;
  1239.     }
  1241.     public function setLastSchoolName(?string $lastSchoolName): self
  1242.     {
  1243.         $this->lastSchoolName = $lastSchoolName;
  1245.         return $this;
  1246.     }
  1248.     public function getBrevoId(): ?string
  1249.     {
  1250.         return $this->brevoId;
  1251.     }
  1253.     public function setBrevoId(?string $brevoId): self
  1254.     {
  1255.         $this->brevoId = $brevoId;
  1257.         return $this;
  1258.     }
  1260.     /**
  1261.      * @return Collection<int, LogSms>
  1262.      */
  1263.     public function getSms(): Collection
  1264.     {
  1265.         return $this->sms;
  1266.     }
  1268.     public function addSms(LogSms $sms): static
  1269.     {
  1270.         if (!$this->sms->contains($sms)) {
  1271.             $this->sms->add($sms);
  1272.             $sms->setUser($this);
  1273.         }
  1275.         return $this;
  1276.     }
  1278.     public function removeSms(LogSms $sms): static
  1279.     {
  1280.         if ($this->sms->removeElement($sms)) {
  1281.             // set the owning side to null (unless already changed)
  1282.             if ($sms->getUser() === $this) {
  1283.                 $sms->setUser(null);
  1284.             }
  1285.         }
  1287.         return $this;
  1288.     }
  1289. }