Symfony Profiler

<?php
namespace App\Controller\GuardianRegister;
use App\Entity\Consent;
use App\Entity\Guardian;
use App\Entity\GuardianRegister\GuardianRegister;
use App\Entity\GuardianRegister\GuardianRegisterChild;
use App\Entity\GuardianRegister\GuardianRegisterVerification;
use App\Form\GuardianShortRegister\GuardianShortRegisterCodeConfirmType;
use App\Form\GuardianShortRegister\GuardianShortRegisterContactStepType;
use App\Form\GuardianShortRegister\GuardianShortRegisterGuardianInfoType;
use App\Message\SendMailMessage;
use App\Repository\ChildRepository;
use App\Repository\ConfigurationRepository;
use App\Repository\DiscountCouponRepository;
use App\Repository\GuardianRegister\GuardianRegisterRepository;
use App\Repository\GuardianRegister\GuardianRegisterVerificationRepository;
use App\Repository\GuardianRepository;
use App\Repository\ReminderConfigurationRepository;
use App\Repository\TeacherRepository;
use App\Repository\UserBlacklistRepository;
use App\Service\GuardianRegisterDuplicateReconciliationService;
use App\Service\OmnisendService;
use App\Service\RefererService;
use App\Service\SmsService;
use App\Utils\HelperUtils;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\FormError;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Annotation\Route;
/**
* @Route("/registracija")
*/
class GuardianShortRegisterV3Controller extends AbstractController
{
private const TYPE_GUARDIAN = 'tevams';
private const TYPE_STUDENT = 'mokiniai';
private const LEGACY_TYPE_STUDENT = 'mokiniams';
private const EXISTING_EMAIL_ERROR = 'Šiuo el.pašto adresu jau yra paskyra sistemoje. Prisijunkite <a href="https://app.corepetitus.lt">app.corepetitus.lt</a> arba susisiekite su administracija. +370 610 40 856';
private const EXISTING_PHONE_ERROR = 'Šiuo telefono numeriu jau yra paskyra sistemoje. Prisijunkite <a href="https://app.corepetitus.lt">app.corepetitus.lt</a> arba susisiekite su administracija. +370 610 40 856';
private const BLACKLIST_ERROR = 'Registracija negalima. Jūsų duomenys sutampa su platformos apribotų vartotojų sąrašu. Prašome susisiekti su administracija dėl tolimesnės informacijos +370 610 40 856.';
private SmsService $smsService;
private EntityManagerInterface $entityManager;
private ReminderConfigurationRepository $reminderConfigurationRepository;
private GuardianRepository $guardianRepository;
private GuardianRegisterRepository $guardianRegisterRepository;
private ConfigurationRepository $configurationRepository;
private ChildRepository $childRepository;
private MessageBusInterface $messageBus;
private GuardianRegisterVerificationRepository $guardianRegisterVerificationRepository;
private OmnisendService $omnisendService;
private DiscountCouponRepository $discountCouponRepository;
private TeacherRepository $teacherRepository;
private UserBlacklistRepository $userBlacklistRepository;
private GuardianRegisterDuplicateReconciliationService $guardianRegisterDuplicateReconciliationService;
public function __construct(
SmsService $smsService,
UserBlacklistRepository $userBlacklistRepository,
ChildRepository $childRepository,
EntityManagerInterface $entityManager,
ConfigurationRepository $configurationRepository,
GuardianRepository $guardianRepository,
GuardianRegisterRepository $guardianRegisterRepository,
ReminderConfigurationRepository $reminderConfigurationRepository,
MessageBusInterface $messageBus,
GuardianRegisterVerificationRepository $guardianRegisterVerificationRepository,
OmnisendService $omnisendService,
DiscountCouponRepository $discountCouponRepository,
TeacherRepository $teacherRepository,
GuardianRegisterDuplicateReconciliationService $guardianRegisterDuplicateReconciliationService
) {
$this->smsService = $smsService;
$this->entityManager = $entityManager;
$this->reminderConfigurationRepository = $reminderConfigurationRepository;
$this->guardianRepository = $guardianRepository;
$this->guardianRegisterRepository = $guardianRegisterRepository;
$this->configurationRepository = $configurationRepository;
$this->childRepository = $childRepository;
$this->messageBus = $messageBus;
$this->guardianRegisterVerificationRepository = $guardianRegisterVerificationRepository;
$this->omnisendService = $omnisendService;
$this->discountCouponRepository = $discountCouponRepository;
$this->teacherRepository = $teacherRepository;
$this->userBlacklistRepository = $userBlacklistRepository;
$this->guardianRegisterDuplicateReconciliationService = $guardianRegisterDuplicateReconciliationService;
}
/**
* @Route("/", name="guardian_short_register_v2", methods={"GET", "POST"})
* @Route("/{type}/{step}", name="guardian_short_register_v2_type", methods={"GET", "POST"})
*/
public function register(Request $request, RefererService $refererService, RequestStack $requestStack, $type = null, $step = null): Response
{
$refererService->setReferer();
if ($redirect = $this->getRedirectType($request, $type)) {
return $this->redirectToStep($redirect, 1);
}
if (!$type) {
return $this->renderStart();
}
if ($step === 'end') {
return $this->renderSuccess($requestStack, $type);
}
if ((int) $step === 0) {
return $this->redirectToRoute('guardian_short_register_v2');
}
$guardianRegister = $this->getGuardianRegisterFromSession($requestStack);
if ((int) $step === 1) {
return $this->handleContactStep($request, $requestStack, $guardianRegister, $type);
}
if ((int) $step === 2 && $this->isStudentType($type)) {
return $this->handleGuardianInfoStep($request, $requestStack, $guardianRegister, $type);
}
if ($this->isCodeConfirmStep($type, (int) $step)) {
return $this->handleCodeConfirmStep($request, $requestStack, $guardianRegister, $type);
}
return $this->redirectToStep($type, 1);
}
private function handleContactStep(Request $request, RequestStack $requestStack, GuardianRegister $guardianRegister, string $type): Response
{
$form = $this->createForm(GuardianShortRegisterContactStepType::class, $guardianRegister, [
'type' => $this->getFormType($type),
]);
$form->handleRequest($request);
if ($form->isSubmitted()) {
$email = $this->normalizeEmail($guardianRegister->getEmail());
$guardianRegister->setEmail($email);
$this->saveStudentClass($form, $requestStack);
$phone = $this->normalizePhoneForCountry($guardianRegister->getPhone(), $form->get('country')->getData());
$guardianRegister->setPhone($phone);
$phoneForSearch = $this->normalizeLithuanianPhone($phone);
$this->validateContactEmail($form, $email, $phoneForSearch);
$this->validateContactPhone($form, $email, $phoneForSearch);
$this->validateReferralCode($form, $guardianRegister->getReferralCode());
if ($form->isValid()) {
$requestStack->getSession()->set('guardianRegister', serialize($guardianRegister));
$this->saveConsent($guardianRegister, $type);
return $this->redirectToStep($type, 2);
}
}
return $this->renderStep($form, 1, $this->getTemplateType($type), $guardianRegister);
}
private function handleGuardianInfoStep(Request $request, RequestStack $requestStack, GuardianRegister $guardianRegister, string $type): Response
{
$studentEmail = $this->normalizeEmail($guardianRegister->getEmail());
$form = $this->createForm(GuardianShortRegisterGuardianInfoType::class, $guardianRegister);
$form->handleRequest($request);
if ($form->isSubmitted()) {
$email = $this->normalizeEmail($guardianRegister->getGuardianEmail());
$guardianRegister->setGuardianEmail($email);
$phone = $this->normalizePhoneForCountry($guardianRegister->getGuardianPhone(), $form->get('country')->getData());
$guardianRegister->setGuardianPhone($phone);
$phoneForSearch = $this->normalizeLithuanianPhone($phone);
$this->validateGuardianContact($form, $email, $phoneForSearch);
$emailsMatch = $email && $email === $studentEmail;
if ($emailsMatch) {
$errorMessage = 'Mokinio ir tėvo el. pašto adresai negali sutapti';
$form->get('guardianEmail')->addError(new FormError($errorMessage));
}
if ($guardianRegister->getPhone() === $guardianRegister->getGuardianPhone()) {
$form->get('guardianPhone')->addError(new FormError('Telefono numeriai negali sutapti.'));
}
if ($form->isValid() && !$emailsMatch) {
$requestStack->getSession()->set('guardianRegister', serialize($guardianRegister));
return $this->redirectToStep($type, 3);
}
}
return $this->renderStep($form, 2, $this->getTemplateType($type), $guardianRegister);
}
private function handleCodeConfirmStep(Request $request, RequestStack $requestStack, GuardianRegister $guardianRegister, string $type): Response
{
$form = $this->createForm(GuardianShortRegisterCodeConfirmType::class, $guardianRegister);
$form->handleRequest($request);
$phone = (string) $this->normalizeLithuanianPhone($guardianRegister->getPhone());
$verification = $this->getOrCreateVerification($phone);
$this->sendVerificationSMS($verification);
$code = $form->get('code')->getData();
if ($code) {
$this->validateVerificationCode($form, $phone, $code);
if ($form->isSubmitted() && $form->isValid()) {
$requestStack->getSession()->set('guardianRegister', serialize($guardianRegister));
$this->finishRegistration($request, $requestStack, $guardianRegister, $type);
return $this->redirectToStep($type, 'end');
}
}
return $this->renderStep($form, $this->getCodeConfirmStep($type), $this->getTemplateType($type), $guardianRegister);
}
private function validateContactEmail(FormInterface $form, ?string $email, ?string $phone): void
{
if (!$email) {
return;
}
$leftGuardians = $this->findGuardians($email, null, Guardian::FORMER_CLIENT_STATUSES);
$guardians = $leftGuardians ? [] : $this->findGuardians($email);
$children = $this->findChildren($email);
if ($guardians || $children) {
$form->get('email')->addError(new FormError(self::EXISTING_EMAIL_ERROR));
}
if ($this->checkBlackList($email, $phone)) {
$form->get('email')->addError(new FormError(self::BLACKLIST_ERROR));
}
}
private function validateContactPhone(FormInterface $form, ?string $email, ?string $phone): void
{
$leftGuardians = $this->findGuardians($email, $phone, Guardian::FORMER_CLIENT_STATUSES);
$guardians = $leftGuardians ? [] : $this->findGuardians($email, $phone);
$children = $this->findChildren($email, $phone);
if ($guardians || $children) {
$form->get('phone')->addError(new FormError(self::EXISTING_PHONE_ERROR));
}
}
private function validateGuardianContact(FormInterface $form, ?string $email, ?string $phone): void
{
$leftGuardians = $this->findGuardians($email, $phone, [Guardian::STATUS_LEFT['value'], Guardian::STATUS_OVERPAID['value']]);
$guardians = $leftGuardians ? [] : $this->findGuardians($email, $phone);
$children = $this->findChildren($email, $phone);
if ($guardians || $children) {
$form->get('guardianEmail')->addError(new FormError(self::EXISTING_EMAIL_ERROR));
}
if ($this->checkBlackList($email, $phone)) {
$form->get('guardianEmail')->addError(new FormError(self::BLACKLIST_ERROR));
}
}
private function validateReferralCode(FormInterface $form, ?string $referralCode): void
{
if (!$referralCode) {
return;
}
$discountCoupon = $this->discountCouponRepository->findOneByCodeValidAt($referralCode, new \DateTime());
$teacher = $this->teacherRepository->findOneBy(['referralCode' => $referralCode]);
$guardian = $this->guardianRepository->findOneBy(['referralCode' => $referralCode]);
if (!$discountCoupon && !$teacher && !$guardian) {
$form->get('referralCode')->addError(new FormError('Toks nuolaidos kodas neegzistuoja.'));
}
if ($discountCoupon && $discountCoupon->getValidFrom() > new \DateTime() && !$teacher && !$guardian) {
$form->get('referralCode')->addError(new FormError('Toks nuolaidos kodas neegzistuoja.'));
}
if ($discountCoupon && $discountCoupon->getValidTo() < new \DateTime() && !$teacher && !$guardian) {
$form->get('referralCode')->addError(new FormError('Nuolaidos kodo galiojimo laikas pasibaigė.22'));
}
}
private function findGuardians(?string $email = null, ?string $phone = null, array $statuses = []): array
{
$query = $this->guardianRepository->createQueryBuilder('g');
$this->addEmailOrPhoneFilter($query, 'g.email', 'g.phoneNumber', $email, $phone);
if ($statuses) {
$query
->andWhere('g.status IN (:statuses)')
->setParameter('statuses', $statuses);
}
return $query->getQuery()->getResult();
}
private function findChildren(?string $email = null, ?string $phone = null): array
{
$query = $this->childRepository->createQueryBuilder('c');
$this->addEmailOrPhoneFilter($query, 'c.email', 'c.phoneNumber', $email, $phone);
return $query->getQuery()->getResult();
}
private function addEmailOrPhoneFilter($query, string $emailField, string $phoneField, ?string $email, ?string $phone, ?string $secondaryPhoneField = null): void
{
$conditions = [];
if ($email) {
$conditions[] = "{$emailField} = :email";
$query->setParameter('email', $email);
}
if ($phone) {
$conditions[] = "{$phoneField} LIKE :phone";
$query->setParameter('phone', "%{$phone}%");
if ($secondaryPhoneField) {
$conditions[] = "{$secondaryPhoneField} LIKE :phone";
}
}
if (!$conditions) {
$query->andWhere('1 = 0');
return;
}
$query->andWhere($query->expr()->orX(...$conditions));
}
private function finishRegistration(Request $request, RequestStack $requestStack, GuardianRegister $guardianRegister, string $type): void
{
$guardianRegister->setIsGuardian($this->isGuardianType($type));
$guardianRegister->setPriceChange($this->getDefaultGuardianPriceChange());
$this->setCurrentGuardianFoundBy($guardianRegister);
$this->saveGoogleTracking($request, $guardianRegister);
$this->saveSessionTracking($requestStack, $guardianRegister);
$guardianRegister->setCreatedAt(new \DateTime());
$this->entityManager->persist($guardianRegister);
$this->entityManager->flush();
$this->guardianRegisterDuplicateReconciliationService->markIfDuplicate($guardianRegister);
$this->addStudentClassChild($requestStack, $guardianRegister);
$this->sendSuccessEmail($guardianRegister);
$this->trackSignup($guardianRegister);
}
private function getDefaultGuardianPriceChange()
{
$configuration = $this->configurationRepository->findOneBy(['name' => 'DEFAULT_GUARDIAN_PRICE_CHANGE']);
return $configuration ? $configuration->getValue() : null;
}
private function setCurrentGuardianFoundBy(GuardianRegister $guardianRegister): void
{
$foundByEmail = false;
$foundByPhone = false;
if ($guardianRegister->getEmail() && $this->guardianRepository->findOneBy(['email' => $guardianRegister->getEmail()])) {
$foundByEmail = true;
}
if ($guardianRegister->getGuardianEmail() && $this->guardianRepository->findOneBy(['email' => $guardianRegister->getGuardianEmail()])) {
$foundByEmail = true;
}
foreach ([$guardianRegister->getPhone(), $guardianRegister->getGuardianPhone()] as $phone) {
if ($this->hasExistingPhone($phone)) {
$foundByPhone = true;
}
}
if ($foundByEmail && $foundByPhone) {
$guardianRegister->setCurrentGuardianFoundBy('EMAIL&TEL');
} elseif ($foundByEmail) {
$guardianRegister->setCurrentGuardianFoundBy('EMAIL');
} elseif ($foundByPhone) {
$guardianRegister->setCurrentGuardianFoundBy('TEL');
}
}
private function hasExistingPhone(?string $phone): bool
{
$phoneToSearch = $this->phoneToSearch($phone);
if (!$phoneToSearch) {
return false;
}
return $this->findGuardians(null, $phoneToSearch) || $this->findChildren(null, $phoneToSearch);
}
private function saveGoogleTracking(Request $request, GuardianRegister $guardianRegister): void
{
$gaCookie = $request->cookies->get('_ga');
if ($gaCookie) {
$guardianRegister->setGoogleClientId(str_replace('GA1.1.', '', $gaCookie));
}
$gaSessionCookie = $request->cookies->get('_ga_T59GXEEM42');
if (!$gaSessionCookie) {
return;
}
if (str_starts_with($gaSessionCookie, 'GA1.1.')) {
$guardianRegister->setGoogleSessionId(explode('.', str_replace('GS1.1.', '', $gaSessionCookie))[0]);
}
if (str_starts_with($gaSessionCookie, 'GS2.1.')) {
$guardianRegister->setGoogleSessionId(explode('.', str_replace('GS2.1.', '', $gaSessionCookie))[0]);
}
}
private function saveSessionTracking(RequestStack $requestStack, GuardianRegister $guardianRegister): void
{
$sessionMap = [
'referer' => 'setReferer',
'refererCategory' => 'setRefererCategory',
'ad' => 'setAd',
'utm_source' => 'setUtmSource',
'utm_medium' => 'setUtmMedium',
'utm_campaign' => 'setUtmCampaign',
'handl_landing_page' => 'setLandingPage',
];
foreach ($sessionMap as $sessionKey => $setter) {
if ($value = $requestStack->getSession()->get($sessionKey)) {
$guardianRegister->{$setter}($value);
}
}
}
private function addStudentClassChild(RequestStack $requestStack, GuardianRegister $guardianRegister): void
{
$guardianRegisterClass = $requestStack->getSession()->get('guardianRegisterClass');
if (!$guardianRegisterClass) {
return;
}
$guardianRegisterChild = (new GuardianRegisterChild())
->setName('Vardas1')
->setClass($guardianRegisterClass)
->setGuardianRegister($guardianRegister);
$guardianRegister->addGuardianRegisterChild($guardianRegisterChild);
$this->entityManager->persist($guardianRegister);
$this->entityManager->persist($guardianRegisterChild);
$this->entityManager->flush();
}
private function trackSignup(GuardianRegister $guardianRegister): void
{
$emailToSend = $guardianRegister->getIsGuardian()
? $guardianRegister->getEmail()
: $guardianRegister->getGuardianEmail();
if (!$emailToSend) {
return;
}
$this->omnisendService->trackEvent($emailToSend, 'UserSignedUp', [
'email' => $guardianRegister->getEmail(),
'phone' => $guardianRegister->getPhone(),
'type' => $guardianRegister->getIsGuardian() ? 'parent' : 'child',
]);
}
private function saveConsent(GuardianRegister $guardianRegister, string $type): void
{
$email = $guardianRegister->getEmail();
$consent = (new Consent())
->setEmail($email)
->setType($type)
->setPhone($guardianRegister->getPhone())
->setHttpRef($this->getHttpData());
$this->entityManager->persist($consent);
$this->entityManager->flush();
if (!$email) {
return;
}
$this->omnisendService->trackEvent($email, 'ConsentGiven', [
'email' => $email,
'type' => 'parent',
]);
}
private function getHttpData(): string
{
return json_encode([
'HTTP_USER_AGENT' => $_SERVER['HTTP_USER_AGENT'] ?? '',
'HTTP_ACCEPT' => $_SERVER['HTTP_ACCEPT'] ?? '',
'HTTP_ACCEPT_LANGUAGE' => $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? '',
'HTTP_ACCEPT_ENCODING' => $_SERVER['HTTP_ACCEPT_ENCODING'] ?? '',
'HTTP_SEC_CH_UA' => $_SERVER['HTTP_SEC_CH_UA'] ?? '',
'HTTP_SEC_CH_UA_MOBILE' => $_SERVER['HTTP_SEC_CH_UA_MOBILE'] ?? '',
'HTTP_SEC_CH_UA_PLATFORM' => $_SERVER['HTTP_SEC_CH_UA_PLATFORM'] ?? '',
'HTTP_CONNECTION' => $_SERVER['HTTP_CONNECTION'] ?? '',
'HTTP_UPGRADE_INSECURE_REQUESTS' => $_SERVER['HTTP_UPGRADE_INSECURE_REQUESTS'] ?? '',
'REMOTE_ADDR' => $_SERVER['REMOTE_ADDR'] ?? '',
'REQUEST_METHOD' => $_SERVER['REQUEST_METHOD'] ?? '',
'REQUEST_URI' => $_SERVER['REQUEST_URI'] ?? '',
'REQUEST_TIME' => $_SERVER['REQUEST_TIME'] ?? time(),
]);
}
private function validateVerificationCode(FormInterface $form, string $phone, string $code): void
{
$verification = $this->guardianRegisterVerificationRepository->findOneBy(['phone' => $phone, 'status' => null]);
if ($verification && $verification->getCode() === $code) {
$verification->setStatus('success');
$this->entityManager->persist($verification);
$this->entityManager->flush();
} else {
$form->get('code')->addError(new FormError('Neteisingas patvirtinimo kodas. Bandykite dar kartą.'));
}
}
private function getOrCreateVerification(string $phone): GuardianRegisterVerification
{
$verification = $this->guardianRegisterVerificationRepository->findOneBy(['phone' => $phone, 'status' => null]);
if ($verification) {
return $verification;
}
$verification = new GuardianRegisterVerification();
$verification->setPhone($phone);
$this->entityManager->persist($verification);
$this->entityManager->flush();
return $verification;
}
public function sendVerificationSMS(GuardianRegisterVerification $guardianRegisterVerification): array
{
$randomNumber = rand(1000, 9999);
$dateNow = new \DateTime();
$dateNow->modify('-3 hours');
if ($guardianRegisterVerification->getSmsVerificationSentAt() && $guardianRegisterVerification->getSmsVerificationSentAt() >= $dateNow) {
return [
'message' => 'Šiuo numeriu jau siuntėme patvirtinimo kodą, jis vis dar galioja. Prašome įvesti gautą kodą, į laukelį žemiau.',
'status' => true,
];
}
$guardianRegisterVerification->setCode($randomNumber);
$guardianRegisterVerification->setSmsVerificationSentAt(new \DateTime());
$this->entityManager->persist($guardianRegisterVerification);
$this->entityManager->flush();
$reminderObject = $this->reminderConfigurationRepository->findOneBy(['reminder_key' => 'REGISTER_PHONE_VERIFICATION']);
$content = str_replace('[CODE]', $randomNumber, $reminderObject->getSmsTemplate());
$phoneNumber = $guardianRegisterVerification->getPhone();
$this->smsService->send($phoneNumber, $content, true);
return [
'message' => "Išsiuntėme aktyvavimo kodą SMS žinute nurodytu numeriu {$phoneNumber}",
'status' => true,
];
}
public function checkBlackList(?string $email, ?string $phoneNumber)
{
if (!$email) {
return false;
}
$phoneNumber = preg_replace('/^\+370/i', '', (string) $phoneNumber);
$blackListed = $this->userBlacklistRepository->createQueryBuilder('u')
->andWhere('u.email = :email OR u.phoneNumber LIKE :phoneNumber')
->setParameter('email', $email)
->setParameter('phoneNumber', "%{$phoneNumber}")
->andWhere('u.userType = :userType')
->setParameter('userType', 'guardian')
->getQuery()
->getResult();
return $blackListed ? 'Toks el. paštas jau yra sistemoje..' : false;
}
public function sendSuccessEmail(GuardianRegister $guardianRegister): void
{
$this->messageBus->dispatch(new SendMailMessage($guardianRegister->getEmail(), '', '', [], 'REGISTER_NOTIF_0'));
}
private function normalizePhoneForCountry(?string $phone, ?string $country): ?string
{
if (!$phone || !$country) {
return $phone;
}
$countryData = HelperUtils::countryData();
if (!isset($countryData[$country])) {
return $phone;
}
$dialCode = $countryData[$country]['dialCode'];
if (!str_starts_with($phone, $dialCode)) {
$phone = $dialCode . $phone;
}
return str_replace('+370+370', '+370', $phone);
}
private function normalizeLithuanianPhone(?string $phone): ?string
{
if (!$phone) {
return null;
}
$phone = preg_replace('/^6/i', '+3706', $phone);
return preg_replace('/^86/i', '+3706', $phone);
}
private function phoneToSearch(?string $phone): ?string
{
if (!$phone || strlen($phone) <= 5) {
return null;
}
$phone = str_replace('+3706', '', $phone);
$phone = str_replace('3706', '', $phone);
return preg_replace('/^86/i', '', $phone);
}
private function normalizeEmail(?string $email): ?string
{
$email = trim((string) $email);
return $email === '' ? null : strtolower($email);
}
private function saveStudentClass(FormInterface $form, RequestStack $requestStack): void
{
if ($form->has('class') && $form->get('class')->getData()) {
$requestStack->getSession()->set('guardianRegisterClass', $form->get('class')->getData());
return;
}
$requestStack->getSession()->set('guardianRegisterClass', null);
}
private function getGuardianRegisterFromSession(RequestStack $requestStack): GuardianRegister
{
$guardianRegister = $requestStack->getSession()->get('guardianRegister');
if ($guardianRegister) {
return unserialize($guardianRegister);
}
return (new GuardianRegister())
->setEmail(null)
->setPhone(null);
}
private function getRedirectType(Request $request, ?string $type): ?string
{
if ($type) {
return null;
}
$redirect = $request->query->get('redirect');
if ($redirect === self::TYPE_GUARDIAN) {
return self::TYPE_GUARDIAN;
}
return $this->isStudentType($redirect) ? self::TYPE_STUDENT : null;
}
private function isCodeConfirmStep(string $type, int $step): bool
{
return ($this->isGuardianType($type) && $step === 2) || ($this->isStudentType($type) && $step === 3);
}
private function getCodeConfirmStep(string $type): int
{
return $this->isGuardianType($type) ? 2 : 3;
}
private function isGuardianType(string $type): bool
{
return $type === self::TYPE_GUARDIAN;
}
private function isStudentType(?string $type): bool
{
return in_array($type, [self::TYPE_STUDENT, self::LEGACY_TYPE_STUDENT], true);
}
private function getFormType(string $type): string
{
return $this->isStudentType($type) ? self::LEGACY_TYPE_STUDENT : $type;
}
private function getTemplateType(string $type): string
{
return $this->isStudentType($type) ? self::LEGACY_TYPE_STUDENT : $type;
}
private function redirectToStep(string $type, $step): Response
{
return $this->redirectToRoute('guardian_short_register_v2_type', [
'type' => $this->isStudentType($type) ? self::TYPE_STUDENT : $type,
'step' => $step,
]);
}
private function renderStep(?FormInterface $form, $step, ?string $type, ?GuardianRegister $guardianRegister = null): Response
{
return $this->renderForm('guardian_register/frontend/short_registration_steps_v2.html.twig', [
'form' => $form,
'step' => $step,
'type' => $type,
'guardianRegister' => $guardianRegister,
]);
}
private function renderStart(): Response
{
return $this->render('guardian_register/frontend/short_registration_steps_v2.html.twig', [
'form' => null,
'step' => 'start',
'type' => null,
]);
}
private function renderSuccess(RequestStack $requestStack, string $type): Response
{
$guardianRegister = $requestStack->getSession()->get('guardianRegister');
if ($guardianRegister) {
$guardianRegister = unserialize($guardianRegister);
}
return $this->render('guardian_register/frontend/short_registration_success.html.twig', [
'guardianRegister' => $guardianRegister,
'step' => 'end',
'type' => $this->getTemplateType($type),
]);
}
}

src/Controller/GuardianRegister/GuardianShortRegisterV3Controller.php line 102