src/Controller/AbsenceController.php line 68

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Interface\Services\AccountantInterface;
  6. use App\Interface\UseCase\VacationListInterface;
  7. use App\Interface\UseCase\Absence\AbsenceInterface;
  8. use Blh\Bundle\Entity\Country;
  9. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\Routing\Annotation\Route;
  12. use Blh\Bundle\Entity\EmployeeAbsenceType;
  13. use Blh\Bundle\Entity\EmployeeVacationTaken;
  14. use Blh\Bundle\Entity\Employee;
  15. use Blh\Bundle\Entity\VwEmployeeVacation;
  16. use Blh\Bundle\Entity\EntityContract;
  17. use Ramsey\Uuid\Uuid;
  18. use Doctrine\ORM\EntityManagerInterface;
  19. use Symfony\Component\HttpFoundation\RedirectResponse;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use Symfony\Component\Workflow\Registry;
  23. use Blh\Bundle\Handler\MailHandler;
  24. use Blh\Bundle\Entity\Email;
  25. use Blh\Bundle\Handler\FileHandler;
  26. use Blh\Bundle\Repository\FileCategoryRepository;
  27. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  28. use Blh\Bundle\Entity\EmployeeVacationTakenFile;
  29. use Blh\Bundle\Entity\File;
  30. use Blh\Bundle\Repository\VwEmployeeVacationRepository;
  31. use Blh\Bundle\Repository\EmployeeRepository;
  34. #[Route('/absence', name: 'absence_')]
  35. class AbsenceController extends AbstractController
  36. {
  37.     private  $AbsencesRequireFile = [1,2]; // estos son los ids de tipos de ausencia que requieren archivos anexos.
  38.     public function __construct(
  39.         private readonly EntityManagerInterface $entityManager,
  40.         private readonly Registry $workflow,
  41.         private readonly MailHandler $mailHandler,
  42.         private readonly ParameterBagInterface $parameters,
  43.         private readonly AccountantInterface $accountant
  44.     ) {}
  47.     #[Route('/list', name: 'index')]
  48.     public function index(): Response
  49.     {
  50.         
  51.         $employeeId = $this->getUser()->getEmployee()->getId();
  52.         $contractType = $this->entityManager->getRepository(Employee::class)->hasContractActive($employeeId)[0]->getContractType($employeeId);
  53.         return $this->render(
  54.             'absence/index.html.twig', 
  55.             ['contractTypeCode' => $contractType->getCode(),
  56.                          'absenceTypes' => $this->entityManager->getRepository(EmployeeAbsenceType::class)->findBy(['isActive' => 1]),
  57.             
  58.         ]);
  59.     }
  61.     #[Route('/report', name: 'report')]
  62.     public function report(): Response
  63.     {
  64.         return $this->render('absence/report.html.twig');
  65.     }
  67.     #[Route('/register', name: 'register',  methods: ['GET', 'POST'])]
  68.     public function registerAction(EmployeeRepository  $employeeRepository): Response
  69.     {
  71.         //Buscamos si el usuario tiene supervisor.
  72.         $immediateBoss = $this->getUser()->getEmployee()->getImmediateBoss();
  73.         
  74.         $contract = null;
  75.         $whitSupervisor = true;
  76.         $whitAccountant = 'yes';
  77.         // Si tiene supervisor verificamos que tenga contrato activo y que no este de vacaciones.
  78.         if ($immediateBoss) {
  79.             
  80.             $supervisorId = $this->getUser()->getEmployee()->getImmediateBoss()->getId();
  81.             
  82.             $contract = $this->entityManager->getRepository(Employee::class)->hasContractActive($supervisorId);
  83.             $inVacation =  $this->entityManager->getRepository(Employee::class)->isInVacation($supervisorId);
  84.             // Si tiene contrato activo obtenemos los nombres.
  86.             if ($contract) {
  87.                 $supervisor = $contract[0]->getEmployee();
  88.                 $supervisorName = $supervisor->getFirstName() . " " . $supervisor->getSurname();
  89.             }
  91.             if (!$contract) {
  92.                 $supervisorName = "No Supervisor with active contract";
  93.                 $whitSupervisor = false;
  94.             }
  96.             if ($inVacation) {
  97.                 $supervisorName = "Supervisor is in vacation currently";
  98.                 $whitSupervisor = false;
  99.             }
  100.         }
  102.         if (!$immediateBoss) {
  103.             $supervisorName = "No associated supervisor";
  104.             $whitSupervisor = false;
  105.         }
  106.         //Verificamos si el pais de donde es el empelado tiene contador. 
  107.         $employee =  $this->getUser()->getEmployee();
  108.         $contract = $this->entityManager->getRepository(Employee::class)->hasContractActive($employee->getId());
  110.         // Esta seccion de codigo es para determinar el pais del empleado y buscar el contador correspondiente.
  111.         $contractEntity = $this->entityManager->getRepository(EntityContract::class)->findBy(['contract' => $contract[0]->getId(), 'isPrincipal' => 1]);
  112.         // Buscamos quien es el accountan del pais donde tiene contrato el solicitante de ausencia.
  114.         $Accountant = $this->accountant->getAccountant($contractEntity[0]);
  115.        
  116.         //En caso que no hayan contadores se coloca la condicion, para dejar un arreglo vacio.
  117.         $accountantEmployeeIds = ($Accountant) ? implode(',', array_column($Accountant, 'employeeId')) : [];
  118.         $accountantActive = $this->entityManager->getRepository(Employee::class)->hasContractActive($accountantEmployeeIds);
  119.         
  120.         $accountantInVacation = $this->entityManager->getRepository(Employee::class)->isInVacation($accountantEmployeeIds);
  121.         //Se indica que no tiene contador asociado si nadie tiene la posicion correspondiente
  122.         //O (hay contador con vacaciones y la cantidad de contadores que existe para dicho pais, es igual a la cantidad de sulicitudes actuales de vacaciones)
  123.         if (!$accountantActive || ($accountantInVacation  && count($accountantInVacation) == count($Accountant))) {
  124.             $whitAccountant = 'no';
  125.         }
  127.         $employeeVacations = $this->entityManager->getRepository(VwEmployeeVacation::class)->find($employee->getId());
  128.         $employeeVacationTaken = $employeeVacations?->getVacationTaken();
  129.         $employeeVacationDays = empty($employeeVacations) ? 100 : $employeeVacations->getVacationDays();
  131.         $vacationDaysPending = $employeeVacationDays - $employeeVacationTaken;
  132.         if (
  133.             !empty($employee->getCity()) &&
  134.             !empty($employee->getCity()->getCountry()) &&
  135.             $employee->getCity()->getCountry()->getId() == Country::BR
  136.         ) {
  137.             $vacationDaysPending = $employeeVacationDays - ($employeeVacationTaken + ($employeeVacationDays - 30) );
  138.         }
  139.         return $this->render('absence/register.html.twig', [
  140.             'controller_name' => 'AbsenceController',
  141.             'supervisorName' => $supervisorName,
  142.             'absenceUuid' => Uuid::uuid4()->toString(),
  143.             'absenceTypes' => $this->entityManager->getRepository(EmployeeAbsenceType::class)->findBy(['isActive' => 1]),
  144.             'employeeVacationDays' => $employeeVacationDays,
  145.             'employeeVacationTaken' => $employeeVacationTaken,
  146.             'whitSupervisor' => $whitSupervisor,
  147.             'whitAccountant' => $whitAccountant,
  148.             'minDaysToRequestVacations' => $this->getParameter('minDaysToRequestVacations'),
  149.             'activeEmployees' => $employeeRepository->selectActiveEmployees(),
  150.             'vacationDaysPending' => $vacationDaysPending
  151.         ]);
  152.     }
  154.     #[Route('/create', name: 'create',  methods: ['POST'])]
  155.     public function createAction(AbsenceInterface $absenceInterface, FileHandler $fileHandler,FileCategoryRepository $fileCategoryRepository, Request $request): JsonResponse
  156.     {
  157.         $parameters =  $request->request->all();
  158.         try {
  159.             $employeeReplacement = $this->entityManager->getRepository(Employee::class)->find($parameters['absence-register-replace']);
  160.             $startDate = new \DateTime($parameters['absence-register-date-start'], new \DateTimeZone('UTC'));
  161.             $startEnd = new \DateTime($parameters['absence-register-date-end'], new \DateTimeZone('UTC'));
  162.             $vacationsEmployee = $this->entityManager->getRepository(EmployeeVacationTaken::class)->vacationByEmployeeIdAndDates($this->getUser()->getEmployee()->getId(), $startDate, $startEnd);
  163.             //Si tiene vacaciones que coinciden con las fechas que intenta registrar ahora se generara un error, para mostrar en el front.
  164.             if ($vacationsEmployee) {
  165.                 throw new \Exception('Coincidence in dates with others absence requested.');
  166.             }
  167.             //Validamos que venga el arcihvo que caso de no ser una vacacion:
  168.             $uploadedFiles = $request->files->get('file-licence-absence');
  169.             // Si no se subio el archivo y el tipo de ausencia requiere archivo
  170.             if (!$uploadedFiles  && (in_array($parameters['absence-register-absence-type'], $this->AbsencesRequireFile))) {
  171.                 throw new \Exception("No file in the request, this is required");
  172.             }
  173.             // Si el tipo de ausencia requiere archivo y hay un error al cargarla.
  174.             if ( (in_array($parameters['absence-register-absence-type'], $this->AbsencesRequireFile))  && !$uploadedFiles[0]->isValid() ) {
  175.                 throw new \Exception('Error uploading file: ' . $uploadedFiles[0]->getErrorMessage());
  176.             }
  177.             $arrayFiles = [];
  178.             if ($uploadedFiles) {
  179.                 $uploadDir = $this->getParameter('kernel.project_dir') . '/public/assets/temp/';
  180.                 
  181.                $arrayFiles =  $absenceInterface->relocateFiles($uploadedFiles, $uploadDir);
  182.                 /*$arrayFiles = [];
  183.                 foreach($uploadedFiles as $fileValue) {
  184.                     // Generar un nombre único para evitar conflictos
  185.                     $newFilename = "abs_".$fileValue->getClientOriginalName().'.' . $fileValue->guessExtension();
  186.                     $fileValue->move($uploadDir, $newFilename);   
  187.                     
  188.                     $arrayFiles[] =[
  189.                         'originFilePath' => $uploadDir.$newFilename,
  190.                         'fileName' => $fileValue->getClientOriginalName(),
  191.                     ];
  192.                 }*/
  193.             }
  194.             $employee = $this->entityManager->getRepository(Employee::class)->find($this->getUser()->getEmployee()->getId());
  195.             $absence = new  EmployeeVacationTaken();
  196.             $absence->setStartDate($startDate);
  197.             $absence->setEndDate($startEnd);
  198.             $absence->setComment($parameters['absence-register-comments']);
  199.             $absence->setReplacement(trim($employeeReplacement->getFirstName()).' '. trim($employeeReplacement->getSurname()));
  200.             $absence->setEmployeeReplacement($employeeReplacement);
  201.             $absence->setEmployee($employee);
  202.             $absence->setEmployeeAbsenceType($this->entityManager->getRepository(EmployeeAbsenceType::class)->find($parameters['absence-register-absence-type']));
  203.             $absence->setDaysTaken($parameters['absence-register-days-absence']);    
  204.             $absence->setWorkflowStep('Pending_Supervisor_Approval');
  205.             $absence->setActive();
  206.             $this->entityManager->persist($absence);
  207.             $this->entityManager->flush();
  209.             //Si el empleado anexo archivo se regitra en la tabla de file
  210.             if ($arrayFiles) {
  211.                 $absenceInterface->registerAndUploadFile($fileCategoryRepository,$fileHandler, $absence, $this->entityManager, $arrayFiles );
  212.                 /*$fileCategory = $fileCategoryRepository->getFileCategory(43);
  213.                 foreach($arrayFiles as $fileToUpload) {
  214.                     $file = $fileHandler->uploadAditionalEmployeeFile(
  215.                         $fileToUpload['originFilePath'], 
  216.                         $fileToUpload['fileName'], 
  217.                         $fileCategory,
  218.                         $employee
  219.                     );
  220.                     //Insertamos en registro en la tabla intermedia entre Ausencias y Vacaciones.
  221.                     $employeeVacationTakenFile = new EmployeeVacationTakenFile();
  222.                     $employeeVacationTakenFile->setVacation($absence);
  223.                     $employeeVacationTakenFile->setFile($file);
  224.                     $this->entityManager->persist($employeeVacationTakenFile);
  225.                     $this->entityManager->flush();
  226.                 }*/
  227.             }
  228.             // Se envia la notificacino:
  229.             $this->sendNotificationMail($absence, 'absence-Pending_Supervisor_Approval');
  230.             return new JsonResponse([
  231.                 'message' => 'OK'
  232.             ], 200);
  233.         } catch (\Exception $e) {
  234.             //dd($e);
  235.             return new JsonResponse([
  236.                 'message' => $e->getMessage()
  237.             ], 500);
  238.         }
  239.     }
  241.     #[Route('/edit/{absence}', name: 'edit', methods: ['GET', 'POST'])]
  242.     public function editAction(Request $request, EmployeeRepository  $employeeRepository,  VwEmployeeVacationRepository $vwEmployeeVacationRepository, EmployeeVacationTaken $absence): Response
  243.     {
  244.         
  245.         $idCurrentEmployee = $this->getUser()->getEmployee()->getId();
  246.         $rolesCurrentUser = $this->getUser()->getRoles();
  247.         
  248.         $dataEmpleado = $vwEmployeeVacationRepository->findEmployeeDetailsById($absence->getEmployee()->getId());
  249.         
  250.         //$employeeVacations = $this->entityManager->getRepository(VwEmployeeVacation::class)->find($this->getUser()->getEmployee()->getId());
  251.         $employeeVacationTaken = $dataEmpleado['vacation_taken'];
  252.         $employeeVacationDays = empty($dataEmpleado['vacation_days']) ? 100 : $dataEmpleado['vacation_days'];
  254.         $supervisorName = ($dataEmpleado['boss_id']) ?
  255.             $dataEmpleado['boss_first_name'] . ' ' . $dataEmpleado['boss_surname']
  256.             : 'Not asociated supervisor';
  257.         $allowActions = [];
  258.         //Variable que nos determina si los campos estaran activos o inactivos
  259.         $fieldsDisabledEnabled = 'disabled';
  261.         //Queremos saber si este usuario tendra la accion de Accountant localmente.
  262.         $contract = $this->entityManager->getRepository(Employee::class)->hasContractActive($idCurrentEmployee);
  263.         $contractEntity = $this->entityManager->getRepository(EntityContract::class)->findBy(['contract' => $dataEmpleado['contract_id'], 'isPrincipal' => 1]);
  264.         
  265.         $accountant = $this->accountant->getAccountant($contractEntity[0]);
  266.         
  267.         //Si hay contador y es el usuario actual.                
  268.         $currentUserIsAccountant =  ($accountant && in_array($this->getUser()->getEmployee()->getId(), array_column($accountant, 'employeeId'))) ? 1 : 0;
  269.         date_default_timezone_set('UTC');
  270.         $currencyDate = new \DateTime();
  272.         //Si el que ingresa al registro es el solicitante
  273.         if (($dataEmpleado['employee_id'] == $idCurrentEmployee && in_array($absence->getWorkflowStep(), ['Pending_Supervisor_Approval', 'Approved_by_Supervisor']))
  274.             || (in_array("ROL_EMPLOYEE_ABSENCE_CANCEL", $this->getUser()->getRoles()) && $absence->getWorkflowStep() != 'canceled')
  275.         ) {
  276.             array_push($allowActions, "cancel");
  277.         }
  278.         //Si tiene supervisor asociado  y Si el que ingresa es el supervisor y esta en estatus pendiente.
  279.         if ($dataEmpleado['boss_id'] && $dataEmpleado['boss_id'] == $idCurrentEmployee && $absence->getWorkflowStep() == 'Pending_Supervisor_Approval') {
  280.             array_push($allowActions, "approve");
  281.             array_push($allowActions, "reject");
  282.         }
  283.         // otro rol que podra editar una ausencia, solo si, tiene el rol ROL_EMPLOYEE_ABSENCE_EDIT
  284.         if (in_array("ROL_EMPLOYEE_ABSENCE_EDIT", $rolesCurrentUser)) {
  285.             $fieldsDisabledEnabled = '';
  286.             array_push($allowActions, "update");
  287.             array_push($allowActions, "cancel");
  288.         }
  289.         if (in_array("ROL_EMPLOYEE_ABSENCE_REJECT", $rolesCurrentUser)) {
  290.             $fieldsDisabledEnabled = '';
  291.             if ($absence->getWorkflowStep() == 'Pending_Supervisor_Approval') {
  292.                 array_push($allowActions, "reject");
  293.             }
  294.         }
  295.         if (in_array("ROL_EMPLOYEE_ABSENCE_APPROVE", $rolesCurrentUser)) {
  296.             $fieldsDisabledEnabled = '';
  297.             if ($absence->getWorkflowStep() == 'Pending_Supervisor_Approval') {
  298.                 array_push($allowActions, "approve");
  299.             }
  300.         }
  301.         // Se podra ELIMINAR una ausencia, solo si, tiene el rol ROL_EMPLOYEE_ABSENCE_DELETE
  302.         // Si la fecha de inicio es mayor a la fecha actual
  303.         // Si esta pendiente.
  304.         if (
  305.             in_array("ROL_EMPLOYEE_ABSENCE_DELETE", $rolesCurrentUser) &&
  306.             ($absence->getStartDate() >= $currencyDate)
  307.         ) {
  308.             if ($absence->getWorkflowStep() == 'Pending_Supervisor_Approval') {
  309.                 $fieldsDisabledEnabled = '';
  310.                 array_push($allowActions, "delete");
  311.             }
  312.         }
  313.         //Buscamos el archivo en caso que tenga uno asociado.
  314.         $fileAsociatedToAbsece = $absence->getFiles()->toArray();
  315.         return $this->render('absence/edit.html.twig', [
  316.             'controller_name' => 'AbsenceController',
  317.             'absence' => $absence,
  318.             'supervisorName' => $supervisorName,
  319.             'absenceTypes' => $this->entityManager->getRepository(EmployeeAbsenceType::class)->findBy(["isActive" => 1]),
  320.             'allowActions' => $allowActions,
  321.             'fieldsDisabledEnabled' => $fieldsDisabledEnabled,
  322.             'employeeVacationDays' => $employeeVacationDays,
  323.             'employeeVacationTaken' => $employeeVacationTaken,
  324.             'currentUserIsAccountant' => $currentUserIsAccountant,
  325.             'backFromAccountingRegistered' => ($request->query->get('ori') == "registerAccountant") ? 1 : 0,
  326.             'backFromUpdated' => ($request->query->get('ori') == "update") ? 1 : 0,
  327.             'activeEmployees' => $employeeRepository->selectActiveEmployees(),
  328.             'files' =>$fileAsociatedToAbsece
  329.         ]);
  330.     }
  332.     #[Route('/update/{absence}', name: 'update', methods: ['POST'])]
  333.     public function updateAction( AbsenceInterface $absenceInterface, FileHandler $fileHandler,FileCategoryRepository $fileCategoryRepository, Request $request, EmployeeVacationTaken $absence): Response
  334.     {
  335.         $parameters =  $request->request->all();
  336.         
  337.         $remplacement = $this->entityManager->getRepository(Employee::class)->find((int)$request->get("absence-register-replace"));
  338.        
  339.        
  340.         //try {
  341.             //Validamos que venga el arcihvo que caso de no ser una vacacion:
  342.             $uploadedFiles = $request->files->get('file-licence-absence');
  343.             $filesToDelete = (trim($parameters['absence-edit-files-to-delete'])!="")?explode(",", $parameters['absence-edit-files-to-delete']):null;
  344.             
  345.             // Si no se subio el archivo y el tipo de ausencia requiere archivo
  346.             /*if (!$uploadedFiles  && (in_array($absence->getEmployeeAbsenceType()->getId(), $this->AbsencesRequireFile))) {
  347.                 throw new \Exception("No file in the request, this is required");
  348.             }
  349.             // Si el tipo de ausencia requiere archivo y hay un error al cargarla.
  350.             if ( (in_array($absence->getEmployeeAbsenceType()->getId(), $this->AbsencesRequireFile))  && !$uploadedFiles[0]->isValid() ) {
  351.                 throw new \Exception(message: 'Error uploading file: ' . $uploadedFiles[0]->getErrorMessage());
  352.             }*/
  353.             $arrayFiles = [];
  354.             if ($uploadedFiles) {
  355.                 $uploadDir = $this->getParameter('kernel.project_dir') . '/public/assets/temp/';
  356.                 $arrayFiles =  $absenceInterface->relocateFiles($uploadedFiles, $uploadDir);
  357.                 /*foreach($uploadedFiles as $fileValue) {
  358.                     // Generar un nombre único para evitar conflictos
  359.                     $newFilename = "abs_".$fileValue->getClientOriginalName().'.' . $fileValue->guessExtension();
  360.                     $fileValue->move($uploadDir, $newFilename);   
  362.                     $arrayFiles[] =[
  363.                         'originFilePath' => $uploadDir.$newFilename,
  364.                         'fileName' => $fileValue->getClientOriginalName(),
  365.                     ];
  366.                 }*/
  367.             }
  368.             if ($request->get("absence-edit-action") == "update") {
  369.                 date_default_timezone_set('UTC');
  370.                 $absence->setStartDate(new \DateTimeImmutable($request->get("absence-register-date-start")));
  371.                 $absence->setEndDate(new \DateTimeImmutable($request->get("absence-register-date-end")));
  372.                 $absence->setComment($request->get("absence-register-comments"));
  373.                 $absence->setReplacement(trim($remplacement->getFirstName()).' '. trim($remplacement->getSurname()));
  374.                 $absence->setEmployeeReplacement($remplacement);
  375.                 $absence->setEmployeeAbsenceType($this->entityManager->getRepository(EmployeeAbsenceType::class)->find($request->get("absence-register-absence-type")));
  376.                 $absence->setDaysTaken($request->get("absence-register-days-absence"));
  377.                 $this->entityManager->persist($absence);
  378.                 $this->sendNotificationMail($absence, 'absence-updated');
  379.                 $edited = true;
  380.             }
  381.             if ($request->get("absence-edit-action") == "delete") {
  382.                 $this->entityManager->remove($absence);
  383.                 // $this->entityManager->persist($absence);
  384.             }
  385.             $stateMachine  = $this->workflow->get($absence, 'absenceVacation');
  386.             if ($request->get("absence-edit-action") == "cancel") {
  387.                 
  388.                 // Se le agrega esta propiedad para ver desde el workflow, si fue RRHH que cancelo y enviar las notificaciones al Contabilidad.
  389.                 if ($absence->getWorkflowStep() != 'Pending_Supervisor_Approval') {
  390.                     $absence->cancelByHR = true;
  391.                 }
  392.                 if ($stateMachine->can($absence, 'to_canceled')) {
  393.                     $stateMachine->apply($absence, 'to_canceled');
  394.                 }
  395.             }
  396.             if ($request->get("absence-edit-action") == "approve") {
  397.                 $approvedDate = new \DateTime(date('Y-m-d'), new \DateTimeZone('UTC'));
  398.                 $absence->setApprovedDate($approvedDate);
  400.                 if ($stateMachine->can($absence, 'to_Approved_by_Supervisor')) {
  401.                     $stateMachine->apply($absence, 'to_Approved_by_Supervisor');
  402.                 }
  403.                 $this->entityManager->persist($absence);
  404.             }
  405.             if ($request->get("absence-edit-action") == "reject") {
  406.                 if ($stateMachine->can($absence, 'to_rejected')) {
  407.                     $stateMachine->apply($absence, 'to_rejected');
  408.                 }
  409.             }
  410.             if ($request->get("absence-edit-action") == "registerAccountant") {
  411.                 $accountingRecordedDate = new \DateTime(date('Y-m-d'), new \DateTimeZone('UTC'));
  412.                 $absence->setAccountingRecordedDate($accountingRecordedDate);
  413.                 $absence->setAccountingRecorded(1);
  414.             }
  415.             $this->entityManager->flush();
  418.             //Si el empleado anexó archivo se regitra en la tabla de file
  419.             if ($arrayFiles) {
  420.                 $absenceInterface->registerAndUploadFile($fileCategoryRepository,$fileHandler, $absence, $this->entityManager, $arrayFiles );
  421.                 /*$fileCategory = $fileCategoryRepository->getFileCategory(43);
  422.                 foreach($arrayFiles as $fileToUpload) {
  423.                     $file = $fileHandler->uploadAditionalEmployeeFile(
  424.                         $fileToUpload['originFilePath'], 
  425.                         $fileToUpload['fileName'], 
  426.                         $fileCategory,
  427.                         $absence->getEmployee()
  428.                     );
  429.                     //Insertamos en registro en la tabla intermedia entre Ausencias y Vacaciones.
  430.                     $employeeVacationTakenFile = new EmployeeVacationTakenFile();
  431.                     $employeeVacationTakenFile->setVacation($absence);
  432.                     $employeeVacationTakenFile->setFile($file);
  433.                     $this->entityManager->persist($employeeVacationTakenFile);
  434.                     $this->entityManager->flush();
  435.                 }*/
  436.             }
  437.             
  438.             //Si el usuario requirio eliminar archivos ya existentes
  439.             if ($filesToDelete){
  440.                 foreach ($filesToDelete as  $fileId) {
  441.                    $dataFile = $this->entityManager->getRepository(File::class)->find( $fileId);
  442.                    $fileHandler->simpleDeleteFile($dataFile);
  443.                    $dataEmployeeVacationTakenFile = $this->entityManager->getRepository(EmployeeVacationTakenFile::class)->findBy(['file' => $fileId ] );
  444.                    //Eliminar registros de File.
  445.                    $this->entityManager->remove($dataFile);
  446.                    //Eliminamos de la tabla employee_vacation_taken_file
  447.                    $this->entityManager->remove($dataEmployeeVacationTakenFile[0]);
  448.                    $this->entityManager->flush();                
  449.                 }
  452.             }
  454.             return ($request->get("absence-edit-action") == "delete") ?
  455.                 $this->redirect($this->generateUrl('absence_index') . '?id=' . $absence->getId()) :
  456.                 $this->redirect($this->generateUrl('absence_edit', ["absence" => $absence->getId()]) . "&ori=" . $request->get("absence-edit-action"));
  457.         /*} catch (\Exception $e) {
  458.             //dd($e);
  459.             return new JsonResponse([
  460.                 'message' => $e->getMessage()
  461.             ], 500);
  462.         }*/    
  463.     
  464.     }
  466.     #[Route('/{isPendingAccounting}/table/{year}/{month}/{day}/{absenceType}', name: 'table', methods: ['GET'], defaults: ["year" => 0, "month" => 0, "day" => 0, "isPendingAccounting" => 0, "absenceType" => 0])]
  467.     public function table(
  468.         VacationListInterface $vacationList,
  469.         int $year,
  470.         int $month,
  471.         int $day,
  472.         int $isPendingAccounting,
  473.         int $absenceType
  474.     ): Response {
  476.         return $this->json($vacationList->getData($year, $month, $day, $isPendingAccounting, $absenceType));
  477.     }
  479.     public function sendNotificationMail(EmployeeVacationTaken $absence, $typeNotify)
  480.     {
  481.         
  482.         $emailToSend = $this->entityManager->getRepository(Email::class)->findOneBy([
  483.             'name' => $typeNotify
  484.         ]);
  485.         $employee = $absence->getEmployee();
  486.         $EmployeeName = $employee->getFirstName() . ' ' . $employee->getSurName();
  487.         $cmEmail = $this->entityManager->getRepository(Employee::class)->findEmailsByPositionInCountry($employee, 'CM');
  488.         $ccEmail = $this->entityManager->getRepository(Employee::class)->findEmailsByPositionInCountry($employee, 'CC');
  489.         $cmEmail = array_merge($cmEmail, $ccEmail);
  490.         
  491.         if ($typeNotify == 'absence-updated') {
  493.             $contract = $this->entityManager->getRepository(Employee::class)->hasContractActive($employee->getId());
  495.             $entityContract = $this->entityManager->getRepository(EntityContract::class)->findOneBy(['contract' => $contract[0]->getId(), 'isPrincipal' => 1]);
  496.             $a3code = $entityContract->getEntity()->getCountry()->getA3code();
  498.             $positionAccountant = $this->parameters->get('absence_position_notification_by_country')[$a3code];
  499.             $employeeAccountant = $this->entityManager->getRepository(Employee::class)->getEmployeeByCountryAndPosition($entityContract->getEntity()->getCountry()->getId(), $positionAccountant);
  500.             foreach ($employeeAccountant as $contract) {
  501.                 $sendTo[] = $contract->getEmployee()->getCorporateEmail();
  502.             }
  504.             //$sendTo[] = ($employeeAccountant)?$employeeAccountant[0]->getEmployee()->getCorporateEmail():"";
  506.             //$sendTo[] = 'mjordan+100@bizlatinhub.com';
  508.             
  509.             array_push($sendTo, $employee->getCorporateEmail());
  510.             array_push($sendTo, $employee->getImmediateBoss()->getCorporateEmail());
  511.             $sendTo = array_merge($sendTo, $cmEmail);
  512.         }
  513.         if ($typeNotify == 'absence-Pending_Supervisor_Approval') {
  514.             $sendTo = [$employee->getImmediateBoss()->getCorporateEmail()];
  515.         }
  516.         $emailsForNotification =
  517.             [
  518.                 MailHandler::RECEIVER_TO => $sendTo,
  519.                 MailHandler::RECEIVER_CC =>  explode(",", $emailToSend->getSendCc()),
  520.                 MailHandler::RECEIVER_BCC => explode(",", $emailToSend->getSendBcc())
  521.             ];
  522.         $subject = str_replace('{{employeeName}}', $EmployeeName, $emailToSend->getSubject());
  523.         $this->mailHandler->sendEmailByApi(
  524.             $emailToSend->setSubject($subject),
  525.             $emailsForNotification,
  526.             ['process' => $absence]
  527.         );
  529.         $this->entityManager->detach($emailToSend);
  530.     }
  531. }