Symfony Profiler

<?php
namespace App\Controller;
use App\Entity\AssignedBadge;
use App\Entity\Badge;
use App\Entity\CompanyOrder;
use App\Entity\ErrorStamped;
use App\Entity\Operator;
use App\Entity\Stamped;
use App\Form\StampedInOutType;
use App\Form\StampedMensaType;
use App\Repository\StampedRepository;
use App\Utils\DateTimeUtils;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Config\Definition\Exception\Exception;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
use Symfony\Component\Routing\Annotation\Route;
class DefaultController extends AbstractController
{
private $doctrine;
public function __construct(ManagerRegistry $doctrine)
{
$this->doctrine = $doctrine;
}
/**
* @Route("/", name="home", methods={"GET","POST"})
* @param StampedRepository $stampedRepository
* @return Response
* @throws \Exception
*/
public function index(StampedRepository $stampedRepository): Response
{
if ($this->isGranted("ROLE_ADMIN_EMZA")) {
return $this->redirectToRoute('stamped_index', ['page' => '1', 'companyOrderType' => CompanyOrder::TYPE_EMZA]);
} elseif ($this->isGranted("ROLE_ADMIN")) {
return $this->redirectToRoute('stamped_index', ['page' => '1', 'companyOrderType' => CompanyOrder::TYPE_CANTIERE]);
}elseif ($this->isGranted("ROLE_ADMIN_MENSA")) {
return $this->redirectToRoute('stamped_index', ['page' => '1', 'companyOrderType' => CompanyOrder::TYPE_MENSA]);
}elseif ($this->isGranted("ROLE_ADMIN_CANTIERE")) {
return $this->redirectToRoute('stamped_index', ['page' => '1', 'companyOrderType' => CompanyOrder::TYPE_CANTIERE]);
} elseif ($this->isGranted("ROLE_MENSA")) {
$form = $this->createForm(StampedMensaType::class);
$userCompanyOrder = $this->get('security.token_storage')->getToken()->getUser()->getCompanyOrder();
return $this->render('default/home-mensa.html.twig', [
'form' => $form->createView(),
'userCompany' => $userCompanyOrder,
]);
} else {
$form = $this->createForm(StampedInOutType::class);
$userCompanyOrder = $this->get('security.token_storage')->getToken()->getUser()->getCompanyOrder();
return $this->render('default/home.html.twig', [
'form' => $form->createView(),
'userCompany' => $userCompanyOrder,
]);
}
}
/**
* @Route("/ajax/timbra", name="timbra_ajax", methods={"POST"})
* @param Request $request
* @return Response
* @throws \Exception
*/
public function timbraAjax(Request $request): Response
{
$datas = $request->request->get('data');
$result = new JsonResponse(['Inizializzo il result'], Response::HTTP_BAD_REQUEST);
try {
if (array_key_exists('type', $datas)) {
$typeForm = StampedMensaType::class;
$data = [
'stamped_in_out[Badge' => $datas['stamped_mensa[Badge'],
'stamped_in_out[InOut' => $datas['stamped_mensa[InOut'],
'stamped_in_out[date' => DateTimeUtils::getNow(),
];
$result = $this->saveTimbrate($data, $typeForm, 'Mensa');
} else {
$typeForm = StampedInOutType::class;
foreach ($datas as $data) {
$result = $this->saveTimbrate($data, $typeForm, 'Cantiere');
}
}
} catch (\Exception $ex) {
$result = new JsonResponse(['Non ci sono dati da processare'], Response::HTTP_BAD_REQUEST);
}
return $result;
}
/**
* @param $data
* @param $typeForm
* @param $t
* @return JsonResponse
* @throws \Exception
*/
public function saveTimbrate($data, $typeForm, $t): JsonResponse
{
$form = $this->createForm($typeForm);
$form->submit($data);
if ($form->isSubmitted() && $form->isValid()) {
$actionForm = $data['stamped_in_out[InOut'];
$badgeForm = $data['stamped_in_out[Badge'];
$entityManager = $this->doctrine->getManager();
$userCompanyOrder = $this->get('security.token_storage')->getToken()->getUser()->getCompanyOrder();
$assignedBadgeRepository = $entityManager->getRepository(AssignedBadge::class);
$badgeRepository = $entityManager->getRepository(Badge::class);
$stampedRepository = $entityManager->getRepository(Stamped::class);
$errorStamped = new ErrorStamped();
$errorStamped->setCompanyOrder($userCompanyOrder);
$errorStamped->setCodBadge($badgeForm);
$stamped = new Stamped();
/** @var Badge $badge */
$badge = $badgeRepository->findOneBy(['codBadge' => $badgeForm]);
$dataIn = DateTimeUtils::getNow();
$dataOut = DateTimeUtils::getNow();
try {
if ($data['stamped_in_out[date']) {
if ($actionForm === 'in') {
$dataIn = $t === 'Cantiere' ? new \DateTime($data['stamped_in_out[date']) : DateTimeUtils::getNow();
} elseif ($actionForm === 'out') {
$dataOut = $t === 'Cantiere' ? new \DateTime($data['stamped_in_out[date']) : DateTimeUtils::getNow();;
}
}
} catch (Exception $e) {
return new JsonResponse(['error' => 'Non ci sono settate le date di timbrata'], Response::HTTP_BAD_REQUEST);
}
if ($badge) {
$idBadge = $badge->getId();
/** @var AssignedBadge $assignedBadge */
$assignedBadge = $assignedBadgeRepository->findOneBy(['badge' => $idBadge]);
if ($assignedBadge) {
$operatorBadge = $assignedBadge->getOperator()->getId();
$operatorRepository = $entityManager->getRepository(Operator::class);
/** @var Operator $op */
$op = $operatorRepository->findOneBy(['id' => $operatorBadge]);
if ($actionForm === 'out') {
/** @var Stamped $stamped */
$stamped = $stampedRepository->getStamped($userCompanyOrder, $operatorBadge);
if ($stamped) {
// Controllo duplicati nelle 4 ore precedenti
$stampedRecent = $stampedRepository->getStampedWithinFourHoursRelease($userCompanyOrder, $operatorBadge);
if (!$stampedRecent) {
$stamped->setReleaseDate($dataOut);
}
// Non salviamo se esiste un duplicato, ma non bloccamo l'esecuzione
} else {
/** @var Stamped $stampedWithinFourHours */
$stampedWithinFourHours = $stampedRepository->getStampedWithinFourHoursRelease($userCompanyOrder, $operatorBadge);
if ($stampedWithinFourHours and $op->getIsMulti() === false and $this->isGranted("ROLE_MENSA")) {
return new JsonResponse(['Non puoi mangiare in mensa piu volte nel giro di poco'], Response::HTTP_BAD_REQUEST);
}
// Crea una nuova timbrata se non esiste duplicato nelle 4 ore precedenti OPPURE se operatore è multi per mensa
if (!$stampedWithinFourHours || ($op->getIsMulti() === true && $this->isGranted("ROLE_MENSA"))) {
$stamped = new Stamped();
$stamped->setCompanyOrder($userCompanyOrder);
$stamped->setOperator($op);
$stamped->setReleaseDate($dataOut);
$stamped->setStatus(Stamped::STATUS_ERROR);
} else {
// Se esiste un duplicato e non è multi, non creiamo un nuovo record
$stamped = null;
}
}
} elseif ($actionForm === 'in') {
/** @var Stamped $stampedWithinFourHours */
$stampedWithinFourHours = $stampedRepository->getStampedWithinFourHoursEntry($userCompanyOrder, $operatorBadge);
if ($stampedWithinFourHours and $op->getIsMulti() === false and $this->isGranted("ROLE_MENSA")) {
return new JsonResponse(['Non puoi mangiare in mensa piu volte nel giro di poco'], Response::HTTP_BAD_REQUEST);
}
// Crea una timbrata se non esiste duplicato nelle 4 ore precedenti OPPURE se operatore è multi per mensa
if (!$stampedWithinFourHours || ($op->getIsMulti() === true && $this->isGranted("ROLE_MENSA"))) {
$stamped->setEntryDate($dataIn);
$stamped->setCompanyOrder($userCompanyOrder);
$stamped->setOperator($op);
if ($this->isGranted("ROLE_MENSA")) {
$stamped->setReleaseDate($dataIn);
}
} else {
// Se esiste un duplicato e non è multi, non creiamo un nuovo record
$stamped = null;
}
}
// Salvo solo se stamped non è null (non è un duplicato)
if ($stamped !== null) {
$entityManager->persist($stamped);
$entityManager->flush();
}
} else {
$errorStamped->setNBadge($badge->getNBadge());
if ($actionForm === 'out') {
$errorStamped->setReleaseDate($dataOut);
} elseif ($actionForm === 'in') {
$errorStamped->setEntryDate($dataIn);
if ($this->isGranted("ROLE_MENSA")) {
return new JsonResponse(['Non sei registrato, richiedere al responsabile l inserimento a sistema'], Response::HTTP_BAD_REQUEST);
}
}
$errorStamped->setType(ErrorStamped::TYPE_ERROR_ASSIGNED);
$entityManager->persist($errorStamped);
$entityManager->flush();
}
} else {
if ($actionForm === 'out') {
$errorStamped->setReleaseDate($dataOut);
} elseif ($actionForm === 'in') {
$errorStamped->setEntryDate($dataIn);
if ($this->isGranted("ROLE_MENSA")) {
return new JsonResponse(['Non sei registrato, richiedere al responsabile l inserimento a sistema'], Response::HTTP_BAD_REQUEST);
}
}
$errorStamped->setType(ErrorStamped::TYPE_ERROR_ASSIGNED);
$entityManager->persist($errorStamped);
$entityManager->flush();
}
} else {
return new JsonResponse(['Il form non è valido contattare l amministratore'], Response::HTTP_BAD_REQUEST);
}
if ($stamped && $badge && $this->isGranted("ROLE_MENSA") && $stamped->getId()) {
return new JsonResponse([
'ok',
'stampedId' => $stamped->getId(),
'badgeStamped' => $badge->getNBadge(),
'codOperator' => $stamped->getOperator()->getId(),
'dataStamped' => $stamped->getCreatedAt()->format('d-m-Y H:i:s')
], Response::HTTP_OK);
} else {
return new JsonResponse(['ok'], Response::HTTP_OK);
}
}
/**
* @Route("/delete-multiple-ids", name="delete_multiple_ids", methods={"DELETE"})
* @IsGranted ("ROLE_ADMIN")
*
* @param Request $request
* @return Response
*/
public function deleteAjax(Request $request): Response
{
if (!$request->request->get('type')) {
return new JsonResponse(['Error, missing type parameter'], Response::HTTP_BAD_REQUEST);
}
$ids = $request->request->get('ids');
if (!$ids || !is_array($request->request->get('ids'))) {
return new JsonResponse(['Error ids not valid'], Response::HTTP_BAD_REQUEST);
}
switch ($request->request->get('type')) {
case 'stamped':
$result = $this->deleteMultipleIds($ids, Stamped::class);
break;
default:
return new JsonResponse(['Error, this type is not registered'], Response::HTTP_BAD_REQUEST);
}
return $result ? new JsonResponse(['ok'], Response::HTTP_OK) : new JsonResponse(['Error while deleting records'], Response::HTTP_BAD_REQUEST);
}
private function deleteMultipleIds(array $ids, $className)
{
try {
$qb = $this->doctrine->getManager()->createQueryBuilder();
$qb->delete($className, 'e')
->andWhere('e.id IN (:id)')
->setParameter('id', $ids);
return $qb->getQuery()->execute();
} catch (Exception $e) {
return false;
}
}
}

src/Controller/DefaultController.php line 39