991 lines
26 KiB
PHP
991 lines
26 KiB
PHP
<?php
|
|
|
|
namespace App\Entity;
|
|
|
|
use App\BusProNet\Model\ProfileResponse;
|
|
use App\Entity\Embeddable\Address;
|
|
use App\Entity\Embeddable\BankAccount;
|
|
use App\Entity\Embeddable\Communication;
|
|
use App\Entity\Traits\SoftDeletableEntity;
|
|
use App\Entity\Traits\TimestampableEntity;
|
|
use App\Enum\MealPreference;
|
|
use App\Repository\TeamerRepository;
|
|
use Doctrine\Common\Collections\ArrayCollection;
|
|
use Doctrine\Common\Collections\Collection;
|
|
use Doctrine\DBAL\Types\Types;
|
|
use Doctrine\ORM\Mapping as ORM;
|
|
use Symfony\Component\Uid\Uuid;
|
|
use Symfony\Component\Validator\Constraints as Assert;
|
|
|
|
#[ORM\Entity(repositoryClass: TeamerRepository::class)]
|
|
class Teamer implements TimestampableEntityInterface, SoftDeletableEntityInterface
|
|
{
|
|
use TimestampableEntity;
|
|
use SoftDeletableEntity;
|
|
|
|
public const STATUS_NEW = 'new';
|
|
public const STATUS_EXISTING = 'existing';
|
|
|
|
public const DRIVER_LICENSE_STATUS_NONE = 'none';
|
|
public const DRIVER_LICENSE_STATUS_PENDING_REVIEW = 'pending_review';
|
|
public const DRIVER_LICENSE_STATUS_APPROVED = 'approved';
|
|
public const DRIVER_LICENSE_STATUS_DENIED = 'denied';
|
|
|
|
#[ORM\Id]
|
|
#[ORM\GeneratedValue]
|
|
#[ORM\Column]
|
|
private ?int $id = null;
|
|
|
|
#[ORM\Column(type: 'string', length: 36, unique: true)]
|
|
private string $uuid;
|
|
|
|
#[ORM\Column(length: 255)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deinen Vornamen an', groups: ['profile'])]
|
|
private ?string $firstName = null;
|
|
|
|
#[ORM\Column(length: 255)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deinen Nachnamen an', groups: ['profile'])]
|
|
private ?string $lastName = null;
|
|
|
|
#[ORM\Column(length: 1)]
|
|
#[Assert\NotBlank(message: 'Bitte gib dein Geschlecht an', groups: ['profile'])]
|
|
private ?string $gender = null;
|
|
|
|
#[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
|
|
#[Assert\NotNull(message: 'Bitte gib dein Geburtsdatum an', groups: ['profile'])]
|
|
private ?\DateTimeImmutable $dateOfBirth = null;
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
private ?string $academicTitle = null;
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
private ?string $salutation = null;
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deine Nationalität an', groups: ['profile'])]
|
|
private ?string $nationality = null;
|
|
|
|
#[ORM\Embedded(class: Address::class)]
|
|
#[Assert\Valid()]
|
|
private ?Address $address = null;
|
|
|
|
#[ORM\Embedded(class: Communication::class)]
|
|
#[Assert\Valid()]
|
|
private ?Communication $communication = null;
|
|
|
|
#[ORM\Embedded(class: BankAccount::class)]
|
|
#[Assert\Valid()]
|
|
private ?BankAccount $bankAccount = null;
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deine SteuerID an', groups: ['profile', 'profile_preflight'])]
|
|
private ?string $taxId = null;
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deine Krankenversicherung an', groups: ['profile', 'profile_preflight'])]
|
|
private ?string $healthInsuranceCompany = null;
|
|
|
|
#[ORM\Column(length: 32)]
|
|
private ?string $status;
|
|
|
|
#[ORM\Column(type: Types::TEXT, nullable: true)]
|
|
private ?string $remarks = null;
|
|
|
|
#[ORM\Column(type: Types::TEXT, nullable: true)]
|
|
private ?string $remarksInternal = null;
|
|
|
|
#[ORM\ManyToMany(targetEntity: Availability::class, inversedBy: 'teamers')]
|
|
#[ORM\OrderBy(['dateFrom' => 'ASC'])]
|
|
private Collection $availabilities;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'owner', targetEntity: Availability::class)]
|
|
private Collection $customAvailabilities;
|
|
|
|
#[ORM\OneToOne(cascade: ['persist', 'remove'], fetch: 'EAGER')]
|
|
#[Assert\NotNull(message: 'Bitte lade ein Foto von dir hoch', groups: ['profile', 'profile_preflight'])]
|
|
private ?Upload $photo = null;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'teamer', targetEntity: Feedback::class, cascade: ['remove'])]
|
|
private Collection $feedback;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'teamer', targetEntity: TrainingAttendance::class, cascade: ['remove'])]
|
|
private Collection $trainingAttendances;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'teamer', targetEntity: License::class, cascade: ['remove'])]
|
|
private Collection $licenses;
|
|
|
|
#[ORM\ManyToMany(targetEntity: JobProfile::class)]
|
|
private Collection $jobProfiles;
|
|
|
|
#[ORM\ManyToMany(targetEntity: Assignment::class, inversedBy: 'teamers')]
|
|
private Collection $bookmarks;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'teamer', targetEntity: Application::class, cascade: ['remove'])]
|
|
private Collection $applications;
|
|
|
|
#[ORM\OneToMany(mappedBy: 'teamer', targetEntity: Disposition::class, cascade: ['remove'])]
|
|
private Collection $dispositions;
|
|
|
|
#[ORM\OneToOne(mappedBy: 'teamer', fetch: 'EXTRA_LAZY')]
|
|
private ?User $user = null;
|
|
|
|
#[ORM\Column]
|
|
private array $pickups = [];
|
|
|
|
#[ORM\Column(length: 255, nullable: true)]
|
|
#[Assert\NotBlank(message: 'Bitte gib deine Sprache(n) an', groups: ['profile', 'profile_preflight'])]
|
|
private ?string $language = null;
|
|
|
|
#[ORM\Column(length: 3, nullable: true)]
|
|
private ?string $size = null;
|
|
|
|
#[ORM\Column(nullable: true, enumType: MealPreference::class)]
|
|
#[Assert\NotNull(message: 'Bitte gib deine Ernährungsweise an', groups: ['profile', 'profile_preflight'])]
|
|
private ?MealPreference $mealPreference = null;
|
|
|
|
#[ORM\Column(nullable: true)]
|
|
private ?array $crmSelections = null;
|
|
|
|
#[ORM\Column]
|
|
private bool $viewed = false;
|
|
|
|
#[ORM\Column]
|
|
private bool $allowOverlappingApplications = false;
|
|
|
|
#[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
|
|
private ?\DateTimeImmutable $dataVerifiedAt = null;
|
|
|
|
#[ORM\Column(nullable: true)]
|
|
private ?bool $driverLicenseDeclaration = null;
|
|
|
|
#[ORM\Column]
|
|
private bool $driverLicenseVerified = false;
|
|
|
|
#[ORM\Column(length: 64)]
|
|
private string $driverLicenseStatus = self::DRIVER_LICENSE_STATUS_NONE;
|
|
|
|
#[ORM\OneToOne(cascade: ['persist', 'remove'])]
|
|
private ?Upload $driverLicenseUpload = null;
|
|
|
|
#[ORM\Column(type: Types::TEXT, nullable: true)]
|
|
private ?string $driverLicenseReviewComment = null;
|
|
|
|
#[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
|
|
private ?\DateTimeImmutable $driverLicenseReviewedAt = null;
|
|
|
|
#[ORM\Column(length: 8, nullable: true)]
|
|
private ?string $driverLicenseReviewedBy = null;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->uuid = Uuid::v4();
|
|
$this->status = static::STATUS_NEW;
|
|
$this->availabilities = new ArrayCollection();
|
|
$this->feedback = new ArrayCollection();
|
|
$this->trainingAttendances = new ArrayCollection();
|
|
$this->licenses = new ArrayCollection();
|
|
$this->jobProfiles = new ArrayCollection();
|
|
$this->bookmarks = new ArrayCollection();
|
|
$this->applications = new ArrayCollection();
|
|
$this->dispositions = new ArrayCollection();
|
|
$this->customAvailabilities = new ArrayCollection();
|
|
}
|
|
|
|
public function __toString()
|
|
{
|
|
return $this->getFullName();
|
|
}
|
|
|
|
public function toPayload(): array
|
|
{
|
|
// Transform gender value
|
|
$gender = strtoupper($this->getGender());
|
|
$gender = 'F' === $gender ? 'W' : $gender;
|
|
|
|
// Ensure date of birth is populated
|
|
if (null === $dob = $this->getDateOfBirth()) {
|
|
$dob = new \DateTimeImmutable('18 years ago');
|
|
}
|
|
|
|
return [
|
|
'geburtsdatum' => $dob->format('d.m.Y'),
|
|
'anrede' => $this->getSalutation(),
|
|
'geschlecht' => $gender,
|
|
'titel' => $this->getAcademicTitle(),
|
|
'vorname' => $this->getFirstName(),
|
|
'name' => $this->getLastName(),
|
|
'anschrift' => $this->getAddress()->toPayload(),
|
|
'kommunikation' => $this->getCommunication()->toPayload(),
|
|
];
|
|
}
|
|
|
|
public static function fromApiResponse(ProfileResponse $profileResponse): static
|
|
{
|
|
$instance = new static();
|
|
|
|
$instance
|
|
->setAcademicTitle($profileResponse->getTitle())
|
|
->setSalutation($profileResponse->getSalutation())
|
|
->setFirstName($profileResponse->getFirstName())
|
|
->setLastName($profileResponse->getName())
|
|
->setGender($profileResponse->getGender())
|
|
->setDateOfBirth($profileResponse->getDateOfBirth())
|
|
;
|
|
|
|
$address = Address::fromApiResponse($profileResponse);
|
|
$communication = Communication::fromApiResponse($profileResponse);
|
|
|
|
$instance
|
|
->setAddress($address)
|
|
->setCommunication($communication)
|
|
;
|
|
|
|
return $instance;
|
|
}
|
|
|
|
public static function fromUserinfo(array $userinfo): static
|
|
{
|
|
$instance = new static();
|
|
|
|
$instance
|
|
->setAcademicTitle($userinfo['profile']['title'] ?? null)
|
|
->setSalutation($userinfo['profile']['salutation'] ?? null)
|
|
->setFirstName($userinfo['profile']['first_name'] ?? null)
|
|
->setLastName($userinfo['profile']['last_name'] ?? null)
|
|
->setGender($userinfo['profile']['gender'] ?? null)
|
|
;
|
|
|
|
if (true === isset($userinfo['profile']['date_of_birth'])) {
|
|
try {
|
|
$dateOfBirth = new \DateTimeImmutable((string) $userinfo['profile']['date_of_birth']);
|
|
$instance->setDateOfBirth($dateOfBirth);
|
|
} catch (\Exception|\TypeError $e) {
|
|
}
|
|
}
|
|
|
|
$address = Address::fromUserinfo($userinfo);
|
|
$communication = Communication::fromUserinfo($userinfo);
|
|
|
|
$instance
|
|
->setAddress($address)
|
|
->setCommunication($communication)
|
|
;
|
|
|
|
return $instance;
|
|
}
|
|
|
|
public function getId(): ?int
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
public function getUuid(): string
|
|
{
|
|
return $this->uuid;
|
|
}
|
|
|
|
public function getFirstName(): ?string
|
|
{
|
|
return $this->firstName;
|
|
}
|
|
|
|
public function setFirstName(?string $firstName): static
|
|
{
|
|
$this->firstName = $firstName;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getLastName(): ?string
|
|
{
|
|
return $this->lastName;
|
|
}
|
|
|
|
public function setLastName(?string $lastName): static
|
|
{
|
|
$this->lastName = $lastName;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getFullName(bool $formal = false): string
|
|
{
|
|
if (true === $formal) {
|
|
return sprintf('%s, %s', $this->getLastName(), $this->getFirstName());
|
|
}
|
|
|
|
return sprintf('%s %s', $this->getFirstName(), $this->getLastName());
|
|
}
|
|
|
|
public function getGender(): ?string
|
|
{
|
|
return $this->gender;
|
|
}
|
|
|
|
public function setGender(?string $gender): static
|
|
{
|
|
$this->gender = $gender;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDateOfBirth(): ?\DateTimeImmutable
|
|
{
|
|
return $this->dateOfBirth;
|
|
}
|
|
|
|
public function setDateOfBirth(?\DateTimeImmutable $dateOfBirth): static
|
|
{
|
|
$this->dateOfBirth = $dateOfBirth;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getAcademicTitle(): ?string
|
|
{
|
|
return $this->academicTitle;
|
|
}
|
|
|
|
public function setAcademicTitle(?string $academicTitle): static
|
|
{
|
|
$this->academicTitle = $academicTitle;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getSalutation(): ?string
|
|
{
|
|
return $this->salutation;
|
|
}
|
|
|
|
public function setSalutation(?string $salutation): static
|
|
{
|
|
$this->salutation = $salutation;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getNationality(): ?string
|
|
{
|
|
return $this->nationality;
|
|
}
|
|
|
|
public function setNationality(?string $nationality): static
|
|
{
|
|
$this->nationality = $nationality;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getAddress(): ?Address
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
public function setAddress(?Address $address): static
|
|
{
|
|
$this->address = $address;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getCommunication(): ?Communication
|
|
{
|
|
return $this->communication;
|
|
}
|
|
|
|
public function setCommunication(?Communication $communication): static
|
|
{
|
|
$this->communication = $communication;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getBankAccount(): ?BankAccount
|
|
{
|
|
return $this->bankAccount;
|
|
}
|
|
|
|
public function setBankAccount(?BankAccount $bankAccount): static
|
|
{
|
|
$this->bankAccount = $bankAccount;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getTaxId(): ?string
|
|
{
|
|
return $this->taxId;
|
|
}
|
|
|
|
public function setTaxId(?string $taxId): static
|
|
{
|
|
$this->taxId = $taxId;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getHealthInsuranceCompany(): ?string
|
|
{
|
|
return $this->healthInsuranceCompany;
|
|
}
|
|
|
|
public function setHealthInsuranceCompany(?string $healthInsuranceCompany): static
|
|
{
|
|
$this->healthInsuranceCompany = $healthInsuranceCompany;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getStatus(): ?string
|
|
{
|
|
return $this->status;
|
|
}
|
|
|
|
public function setStatus(string $status): static
|
|
{
|
|
$this->status = $status;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getRemarks(): ?string
|
|
{
|
|
return $this->remarks;
|
|
}
|
|
|
|
public function setRemarks(?string $remarks): static
|
|
{
|
|
$this->remarks = $remarks;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getRemarksInternal(): ?string
|
|
{
|
|
return $this->remarksInternal;
|
|
}
|
|
|
|
public function setRemarksInternal(?string $remarksInternal): static
|
|
{
|
|
$this->remarksInternal = $remarksInternal;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Availability>
|
|
*/
|
|
public function getAvailabilities(): Collection
|
|
{
|
|
return $this->availabilities;
|
|
}
|
|
|
|
public function addAvailability(Availability $availability): static
|
|
{
|
|
if (!$this->availabilities->contains($availability)) {
|
|
$this->availabilities->add($availability);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeAvailability(Availability $availability): static
|
|
{
|
|
$this->availabilities->removeElement($availability);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Availability>
|
|
*/
|
|
public function getCustomAvailabilities(): Collection
|
|
{
|
|
return $this->customAvailabilities;
|
|
}
|
|
|
|
public function addCustomAvailability(Availability $customAvailability): static
|
|
{
|
|
if (!$this->customAvailabilities->contains($customAvailability)) {
|
|
$this->customAvailabilities->add($customAvailability);
|
|
$customAvailability->setOwner($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeCustomAvailability(Availability $customAvailability): static
|
|
{
|
|
if ($this->customAvailabilities->removeElement($customAvailability)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($customAvailability->getOwner() === $this) {
|
|
$customAvailability->setOwner(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getAllAvailabilities(): Collection
|
|
{
|
|
$allAvailabilities = new ArrayCollection();
|
|
|
|
foreach ($this->getAvailabilities() as $availability) {
|
|
$allAvailabilities->add($availability);
|
|
}
|
|
|
|
foreach ($this->getCustomAvailabilities() as $availability) {
|
|
$allAvailabilities->add($availability);
|
|
}
|
|
|
|
return $allAvailabilities;
|
|
}
|
|
|
|
public function getPhoto(): ?Upload
|
|
{
|
|
return $this->photo;
|
|
}
|
|
|
|
public function setPhoto(?Upload $photo): static
|
|
{
|
|
$this->photo = $photo;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Feedback>
|
|
*/
|
|
public function getFeedback(): Collection
|
|
{
|
|
return $this->feedback;
|
|
}
|
|
|
|
public function addFeedback(Feedback $feedback): static
|
|
{
|
|
if (!$this->feedback->contains($feedback)) {
|
|
$this->feedback->add($feedback);
|
|
$feedback->setTeamer($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeFeedback(Feedback $feedback): static
|
|
{
|
|
if ($this->feedback->removeElement($feedback)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($feedback->getTeamer() === $this) {
|
|
$feedback->setTeamer(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getAverageRating(): ?int
|
|
{
|
|
$feedbackCount = $this->getFeedback()->count();
|
|
|
|
if (0 === $feedbackCount) {
|
|
return null;
|
|
}
|
|
|
|
$sum = 0;
|
|
|
|
foreach ($this->getFeedback() as $feedback) {
|
|
$sum += $feedback->getAverageRating();
|
|
}
|
|
|
|
return $sum / $feedbackCount;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, TrainingAttendance>
|
|
*/
|
|
public function getTrainingAttendances(): Collection
|
|
{
|
|
return $this->trainingAttendances;
|
|
}
|
|
|
|
public function addTrainingAttendance(TrainingAttendance $trainingAttendance): static
|
|
{
|
|
if (!$this->trainingAttendances->contains($trainingAttendance)) {
|
|
$this->trainingAttendances->add($trainingAttendance);
|
|
$trainingAttendance->setTeamer($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeTrainingAttendance(TrainingAttendance $trainingAttendance): static
|
|
{
|
|
if ($this->trainingAttendances->removeElement($trainingAttendance)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($trainingAttendance->getTeamer() === $this) {
|
|
$trainingAttendance->setTeamer(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getTrainingAttendance(Training $training): ?TrainingAttendance
|
|
{
|
|
foreach ($this->getTrainingAttendances() as $attendance) {
|
|
if ($attendance->getTraining() === $training) {
|
|
return $attendance;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, License>
|
|
*/
|
|
public function getLicenses(): Collection
|
|
{
|
|
return $this->licenses;
|
|
}
|
|
|
|
public function addLicense(License $license): static
|
|
{
|
|
if (!$this->licenses->contains($license)) {
|
|
$this->licenses->add($license);
|
|
$license->setTeamer($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeLicense(License $license): static
|
|
{
|
|
if ($this->licenses->removeElement($license)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($license->getTeamer() === $this) {
|
|
$license->setTeamer(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getLicenseOfType(string $type): ?License
|
|
{
|
|
foreach ($this->getLicenses() as $license) {
|
|
if ($type === $license->getType()) {
|
|
return $license;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, JobProfile>
|
|
*/
|
|
public function getJobProfiles(): Collection
|
|
{
|
|
return $this->jobProfiles;
|
|
}
|
|
|
|
public function addJobProfile(JobProfile $jobProfile): static
|
|
{
|
|
if (!$this->jobProfiles->contains($jobProfile)) {
|
|
$this->jobProfiles->add($jobProfile);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeJobProfile(JobProfile $jobProfile): static
|
|
{
|
|
$this->jobProfiles->removeElement($jobProfile);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Assignment>
|
|
*/
|
|
public function getBookmarks(): Collection
|
|
{
|
|
return $this->bookmarks;
|
|
}
|
|
|
|
public function addBookmark(Assignment $bookmark): static
|
|
{
|
|
if (!$this->bookmarks->contains($bookmark)) {
|
|
$this->bookmarks->add($bookmark);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeBookmark(Assignment $bookmark): static
|
|
{
|
|
$this->bookmarks->removeElement($bookmark);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Application>
|
|
*/
|
|
public function getApplications(): Collection
|
|
{
|
|
return $this->applications;
|
|
}
|
|
|
|
public function addApplication(Application $application): static
|
|
{
|
|
if (!$this->applications->contains($application)) {
|
|
$this->applications->add($application);
|
|
$application->setTeamer($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeApplication(Application $application): static
|
|
{
|
|
if ($this->applications->removeElement($application)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($application->getTeamer() === $this) {
|
|
$application->setTeamer(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return Collection<int, Disposition>
|
|
*/
|
|
public function getDispositions(): Collection
|
|
{
|
|
return $this->dispositions;
|
|
}
|
|
|
|
public function addDisposition(Disposition $disposition): static
|
|
{
|
|
if (!$this->dispositions->contains($disposition)) {
|
|
$this->dispositions->add($disposition);
|
|
$disposition->setTeamer($this);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeDisposition(Disposition $disposition): static
|
|
{
|
|
if ($this->dispositions->removeElement($disposition)) {
|
|
// set the owning side to null (unless already changed)
|
|
if ($disposition->getTeamer() === $this) {
|
|
$disposition->setTeamer(null);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getUser(): ?User
|
|
{
|
|
return $this->user;
|
|
}
|
|
|
|
public function setUser(?User $user): static
|
|
{
|
|
$this->user = $user;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getPickups(): array
|
|
{
|
|
return $this->pickups;
|
|
}
|
|
|
|
public function setPickups(array $pickups): static
|
|
{
|
|
$this->pickups = $pickups;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function hasPickup(int $pickupId): bool
|
|
{
|
|
return true === in_array($pickupId, $this->getPickups(), true);
|
|
}
|
|
|
|
public function getDriverLicenseDeclaration(): ?bool
|
|
{
|
|
return $this->driverLicenseDeclaration;
|
|
}
|
|
|
|
public function setDriverLicenseDeclaration(?bool $driverLicenseDeclaration): static
|
|
{
|
|
$this->driverLicenseDeclaration = $driverLicenseDeclaration;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function isDriverLicenseVerified(): bool
|
|
{
|
|
return $this->driverLicenseVerified;
|
|
}
|
|
|
|
public function setDriverLicenseVerified(bool $driverLicenseVerified): static
|
|
{
|
|
$this->driverLicenseVerified = $driverLicenseVerified;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDriverLicenseStatus(): string
|
|
{
|
|
return $this->driverLicenseStatus;
|
|
}
|
|
|
|
public function setDriverLicenseStatus(string $driverLicenseStatus): static
|
|
{
|
|
$this->driverLicenseStatus = $driverLicenseStatus;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDriverLicenseUpload(): ?Upload
|
|
{
|
|
return $this->driverLicenseUpload;
|
|
}
|
|
|
|
public function setDriverLicenseUpload(?Upload $driverLicenseUpload): static
|
|
{
|
|
$this->driverLicenseUpload = $driverLicenseUpload;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDriverLicenseReviewComment(): ?string
|
|
{
|
|
return $this->driverLicenseReviewComment;
|
|
}
|
|
|
|
public function setDriverLicenseReviewComment(?string $driverLicenseReviewComment): static
|
|
{
|
|
$this->driverLicenseReviewComment = $driverLicenseReviewComment;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDriverLicenseReviewedAt(): ?\DateTimeImmutable
|
|
{
|
|
return $this->driverLicenseReviewedAt;
|
|
}
|
|
|
|
public function setDriverLicenseReviewedAt(?\DateTimeImmutable $driverLicenseReviewedAt): static
|
|
{
|
|
$this->driverLicenseReviewedAt = $driverLicenseReviewedAt;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDriverLicenseReviewedBy(): ?string
|
|
{
|
|
return $this->driverLicenseReviewedBy;
|
|
}
|
|
|
|
public function setDriverLicenseReviewedBy(?string $driverLicenseReviewedBy): static
|
|
{
|
|
$this->driverLicenseReviewedBy = $driverLicenseReviewedBy;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getLanguage(): ?string
|
|
{
|
|
return $this->language;
|
|
}
|
|
|
|
public function setLanguage(?string $language): static
|
|
{
|
|
$this->language = $language;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getSize(): ?string
|
|
{
|
|
return $this->size;
|
|
}
|
|
|
|
public function setSize(string $size): static
|
|
{
|
|
$this->size = $size;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getMealPreference(): ?MealPreference
|
|
{
|
|
return $this->mealPreference;
|
|
}
|
|
|
|
public function setMealPreference(?MealPreference $mealPreference): static
|
|
{
|
|
$this->mealPreference = $mealPreference;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getCrmSelections(): ?array
|
|
{
|
|
return $this->crmSelections;
|
|
}
|
|
|
|
public function setCrmSelections(?array $crmSelections): static
|
|
{
|
|
$this->crmSelections = $crmSelections;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function isViewed(): bool
|
|
{
|
|
return $this->viewed;
|
|
}
|
|
|
|
public function setViewed(bool $viewed): static
|
|
{
|
|
$this->viewed = $viewed;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function isAllowOverlappingApplications(): bool
|
|
{
|
|
return $this->allowOverlappingApplications;
|
|
}
|
|
|
|
public function setAllowOverlappingApplications(bool $allowOverlappingApplications): static
|
|
{
|
|
$this->allowOverlappingApplications = $allowOverlappingApplications;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getDataVerifiedAt(): ?\DateTimeImmutable
|
|
{
|
|
return $this->dataVerifiedAt;
|
|
}
|
|
|
|
public function setDataVerifiedAt(?\DateTimeImmutable $dataVerifiedAt): static
|
|
{
|
|
$this->dataVerifiedAt = $dataVerifiedAt;
|
|
|
|
return $this;
|
|
}
|
|
}
|