Symfony Profiler

<?php
namespace App\Controller;
use JMS\Serializer\SerializationContext;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use App\Entity\DemandeReport;
use App\Entity\Conge;
use App\Entity\CongeType;
use App\Entity\CongeDroitAnnuel;
use App\Entity\ParametrageTexte;
use App\Entity\RefRole;
use App\Entity\Utilisateur;
use App\Entity\UtilisateurInformation;
use App\Entity\Workflow;
use App\Form\DemandeReportType;
use App\Entity\RefGabarit;
use App\Entity\RefAffectation;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\Mailer\MailerInterface;
use App\Services\GeneratePdf;
use App\Services\AccessRule;
use JMS\Serializer\SerializerInterface;
use Symfony\Component\Mime\Email;
use App\Services\Lib\EmailSHDecision;
use Twig\Environment;
use App\Entity\RefAffectationCalendrier;
/**
* Class DemandeReportController
* @package App\Controller
*/
class DemandeReportController extends AbstractController
{
final public const ERROR_VALIDATION_FORM = 'Erreur lors de la validation du formulaire';
final public const ERROR_OCCURED = 'Une erreur est survenue';
final public const ERROR_FILE = 'Fichier introuvable';
private $doctrine;
private $mailer;
private $generatePdf;
private $accessRule;
private $serializer;
private $twig;
private $emailSHDecision;
public function __construct(ManagerRegistry $doctrine, MailerInterface $mailer, GeneratePdf $generatePdf, Environment $twig, AccessRule $accessRule, SerializerInterface $serializer, EmailSHDecision $emailSHDecision,)
{
$this->doctrine = $doctrine;
$this->mailer = $mailer;
$this->generatePdf = $generatePdf;
$this->accessRule = $accessRule;
$this->serializer = $serializer;
$this->emailSHDecision = $emailSHDecision;
$this->twig = $twig;
}
#[Route(path: '/api/demandes_report/{id}', name: 'ctsweb_get_demandes_report', methods: ['GET'], requirements: ['id' => '\d+'])]
public function detail(DemandeReport $report): JsonResponse
{
$jsonv = [];
$repositoryUI = $this->doctrine->getManager()->getRepository(UtilisateurInformation::class);
$uid = $report->getUtilisateur()->getIdUtilisateur();
$utilisateurData = $repositoryUI->findDataForPageProfil($uid);
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->hasRightTodetailAccessReport($report)) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
// Obtenir les données sérialisées de "$report" et les décoder en tableau associatif
$reportSerialized = $this->serialize($report);
$reportSerializedArray = json_decode($reportSerialized, true);
$dateRefuseValide = $report->getDateDerniereModification();
$infosValidation['annee'] = $this->getAnneeSaisie($uid, 1);
$infosValidation['dateRefuseValide'] = (isset($dateRefuseValide) && !empty($dateRefuseValide)) ? $dateRefuseValide->format('Y-m-d') : "";
$uData = $this->serialize($utilisateurData);
$jsonv['items']['infos'] = $infosValidation;
$jsonv['items']['conge'] = $reportSerializedArray;
$jsonv['items']['user'] = json_decode((string) $uData, true, 512, JSON_THROW_ON_ERROR);
$json_merge = json_encode($jsonv);
return new JsonResponse($json_merge, JsonResponse::HTTP_OK, [], true);
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/demandes_report', name: 'ctsweb_create_demandes_report', methods: ['POST'])]
public function create(Request $request)
{
$utilisateurInformation = $this->getUser();
$utilisateur = $utilisateurInformation->getUtilisateur();
$idRole = $utilisateur->getIdRole();
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->hasRightForTakingDayOff()) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
$solderestant = false;
$report = new DemandeReport();
$form = $this->handleRequest($request, $report, 'all', 'post');
$em = $this->doctrine->getManager();
$repository = $em->getRepository(DemandeReport::class);
try {
if ($form->isSubmitted() && $form->isValid()) {
$entityManager = $this->doctrine->getManager();
$year = $this->getYear($utilisateurInformation);
if (!$repository->checkDemandeReport($year, $this->getUser())) {
$result = [
'success' => false,
'error' => 'Il y a déjà une demande de report sur cette période ou les dates credit et debit ne sont pas renseignés par le SH'
];
return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
}
$solderestant = $this->solderestant($utilisateur, $report->getNbJour());
if (!$solderestant) {
$result = [
'success' => false,
'error' => 'Le nombre de jour demandé est superieure au solde de congé restante'
];
return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
}
$report->setType(DemandeReport::TYPE_ONE); // Pour définir le type à 1
$entityManager->persist($report);
$this->createReport($report);
$entityManager->flush();
if ($idRole == RefRole::ROLE_CTS || $idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
$this->sendMailNotification();
}
return new JsonResponse(
[
'success' => true,
'Conge' => $report->getId(),
],
JsonResponse::HTTP_CREATED
);
} else {
$result = [
'success' => false,
'data' => self::ERROR_VALIDATION_FORM,
'error' => (string) $form->getErrors(true, false)
];
}
} catch (\Exception $e) {
echo $e->getMessage();
$result = [
'success' => false,
'data' => self::ERROR_OCCURED
];
}
return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/report_solde_ca/{id}', name: 'ctsweb_report_solde_ca', requirements: ['id' => '\d+'])]
public function soldeCa(Utilisateur $report)
{
$entityManager = $this->doctrine->getManager();
$idutilisateur = $report->getidUtilisateur();
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $idutilisateur]);
$year = $this->getYear($utilisateurInformation);
$userInfos = $entityManager
->getRepository(UtilisateurInformation::class)
->getInfos(
$report,
$year
);
$totalCan = isset($userInfos['totalCan']) ? $userInfos['totalCan'] : 0;
$givenCan = isset($userInfos['givenCan']) ? $userInfos['givenCan'] : 0;
$totalfrac = isset($userInfos['totalFrac']) ? $userInfos['totalFrac'] : 0;
$total = $totalCan + $totalfrac;
$result['soldeCan'] = $total - $givenCan;
return new JsonResponse(
$this->serialize($result),
JsonResponse::HTTP_OK,
[],
true
);
}
public function solderestant($report, $nb)
{
$entityManager = $this->doctrine->getManager();
$idutilisateur = $report->getidUtilisateur();
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $idutilisateur]);
$year = $this->getYear($utilisateurInformation);
$userInfos = $entityManager
->getRepository(UtilisateurInformation::class)
->getInfos(
$report,
$year
);
$totalCan = isset($userInfos['totalCan']) ? $userInfos['totalCan'] : 0;
$givenCan = isset($userInfos['givenCan']) ? $userInfos['givenCan'] : 0;
$totalfrac = isset($userInfos['totalFrac']) ? $userInfos['totalFrac'] : 0;
$total = $totalCan + $totalfrac;
$result['soldeCan'] = $total - $givenCan;
if ($result['soldeCan'] < $nb) {
return false;
}
return true;
}
/**
* Fonction pour gérer la création d'un rapport
* @param DemandeReport $report
* @return bool
*/
public function createReport(DemandeReport $report): bool
{
$entityManager = $this->doctrine->getManager();
// Récupérer les informations de l'utilisateur
$utilisateur = $report->getUtilisateur();
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $utilisateur]);
$Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
$affectation = $entityManager
->getRepository(RefAffectation::class)
->findOneBy(["idAffectation" => $Idaffectation]);
$report->setAffectation($affectation);
// $congeScolaire = $affectation->getCalendrierScolaire();
$getRefCalendrier = $entityManager
->getRepository(RefAffectationCalendrier::class)
->getRefCalendrier($Idaffectation);
$congeScolaire = $getRefCalendrier['calendrierScolaire'];
$dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
$today = (new \DateTime());
$year = $today->format("Y");
// $dateBasculeCongeSolaire = $affectation->getDateBascule();
$typeCalendrier = ($congeScolaire) ? 's' : 'c';
$report->setTypeCalendrier($typeCalendrier);
if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
$report->setAnnee($year - 1);
// $report->setAnnee($year);
} else {
$report->setAnnee($year);
// $report->setAnnee($year +1);
}
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->hasRightWithoutCheckAffectation($report->getUtilisateur(), $this->getUser())) {
return false;
}
$entityManager->persist($report);
// $entityManager->flush();
// Retourner une valeur booléenne pour indiquer si la création du rapport a réussi
return true;
}
private function sendMailNotification()
{
$em = $this->doctrine->getManager();
$gabRep = $em->getRepository(RefGabarit::class);
$ui = $this->getUser();
$uid = $this->getUser()->getUtilisateur()->getIdUtilisateur();
$uimail = $em->getRepository(Utilisateur::class)->findBy(['idUtilisateur' => $uid])[0]->getCourriel();
$role = $this->getUser()->getUtilisateur()->getIdRole();
$subject = sprintf('CTS-WEB : Demande de report à valider - %s %s', $ui->getNom(), $ui->getPrenom());
$emailMailer = $this->getParameter('mailer_user');
$expediteurMail = (filter_var($emailMailer, FILTER_VALIDATE_EMAIL)) ? $emailMailer : 'donotreply@sports.gouv.fr';
//$host = $this->getParameter('host');
$mail_contact = null;
$mail_ass_info = $this->doctrine->getManager()->getRepository(ParametrageTexte::class)->getByCode('COURRIEL_ASSISTANCE_INFO');
if ((is_countable($mail_ass_info) ? count($mail_ass_info) : 0) > 0)
$mail_contact = $mail_ass_info[0]->getTexte();
if (RefRole::ROLE_FEDE === $role || RefRole::ROLE_FEDE_INVITE === $role || RefRole::ROLE_CTS === $role) {
$federation = $ui->getIdFederation()->getIdFederation();
$affectation = $ui->getIdAffectation()->getIdAffectation();
} else {
$federation = null;
$affectation = $ui->getIdAffectation()->getIdAffectation();
}
$recipients = $gabRep->emailNotification($federation, $affectation, 'emailConges');
// if (!filter_var($recipients, FILTER_VALIDATE_EMAIL)) {
// $recipients = [];
// }
if (!empty($recipients)) {
$message = (new Email())
->subject($subject)
->from($expediteurMail)
->to(...$recipients)
->html(
$this->twig->render(
'Notification/notification_report_dtn.html.twig',
['host' => $mail_contact, 'civility' => $ui->getCivilite(), 'lastname' => $ui->getNom(), 'firstname' => $ui->getPrenom(), 'mailDemandeur' => $expediteurMail]
),
'text/html'
);
$this->mailer->send($message);
}
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/update_reports/{id}', name: 'ctsweb_update_report', methods: ['POST'], requirements: ['id' => '\d+'])]
public function update(Request $request, DemandeReport $report)
{
$utilisateurInformation = $this->getUser();
$utilisateur = $utilisateurInformation->getUtilisateur();
$idRole = $utilisateur->getIdRole();
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->hashRightToModifyReport($report)) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
// $report = new Conge();
$form = $this->handleRequest($request, $report, 'all', 'post');
$em = $this->doctrine->getManager();
$repository = $em->getRepository(DemandeReport::class);
$popup = false;
if ($form->isSubmitted() && $form->isValid()) {
$em = $this->doctrine->getManager();
$workflow = $em->getRepository(Workflow::class)->find(Workflow::RE_WAITING);
if (Workflow::RE_SIGN !== $report->getWorkflow()->getIdWorkflow())
$report->setWorkflow($workflow);
$entityManager = $this->doctrine->getManager();
if ($idRole == RefRole::ROLE_CTS || $idRole == RefRole::ROLE_FEDE || $idRole == RefRole::ROLE_FEDE_INVITE) {
$solderestant = $this->solderestant($utilisateur, $report->getNbJour());
if (!$solderestant) {
$result = [
'success' => false,
'error' => 'Le nombre de jour demandé est superieure au solde de congé restante'
];
return new JsonResponse($result, JsonResponse::HTTP_BAD_REQUEST);
}
}
$entityManager->persist($report);
$entityManager->flush();
$result = ['success' => true];
$status = JsonResponse::HTTP_OK;
} else {
$result = [
'success' => false,
'data' => self::ERROR_VALIDATION_FORM,
'error' => (string) $form->getErrors(true, false)
];
$status = JsonResponse::HTTP_BAD_REQUEST;
}
return new JsonResponse($result, $status);
}
#[Route(path: '/api/delete_reports/{id}', name: 'ctsweb_delete_report', requirements: ['id' => '\d+'])]
public function delete(DemandeReport $report)
{
try {
$em = $this->doctrine->getManager();
$repository = $em->getRepository(DemandeReport::class);
$cg = $repository->findOneBy(['id' => $report->getId()]);
if ($cg) {
if ($cg->getWorkflow()->getIdWorkflow() == Workflow::RE_SIGN) {
$workflow = $em->getRepository(Workflow::class)->find(Workflow::RE_ANNULE);
$report->setWorkflow($workflow);
$em->persist($report);
$em->flush();
$repository->annulerreport($report);
$data = ['success' => true, 'data' => 'Le report a été annulé'];
return new JsonResponse($data);
} else {
$repository->deleteReport($report);
$data = ['success' => true, 'data' => 'Le report a été supprimé'];
return new JsonResponse($data);
}
}
} catch (\Exception $e) {
$data = ['success' => false, 'data' => $e->getMessage()];
return new JsonResponse($data);
}
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/report/{id}/change-status', name: 'ctsweb_change_status_report', methods: ['POST'], requirements: ['id' => '\d+'])]
public function changeStatus(Request $request, DemandeReport $report)
{
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->isAdmin()) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
$form = $this->handleRequest($request, $report, 'status', 'status');
if ($form->isSubmitted() && $form->isValid()) {
$report->setFrom(DemandeReport::ADMIN);
$entityManager = $this->doctrine->getManager();
$entityManager->flush();
$result = ['success' => true];
$status = JsonResponse::HTTP_OK;
} else {
$result = [
'success' => false,
'data' => self::ERROR_VALIDATION_FORM,
'error' => (string) $form->getErrors(true, false)
];
$status = JsonResponse::HTTP_BAD_REQUEST;
}
return new JsonResponse($result, $status);
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/report/response/{id}', name: 'ctsweb_response_report', methods: ['POST'], requirements: ['id' => '\d+'])]
public function response(Request $request, DemandeReport $report)
{
$form = $this->handleRequest(
$request,
$report,
'response',
'response'
);
if ($form->isValid()) {
$accessRuleService = $this->getServiceAccessRule();
$this->update($request, $report);
if (DemandeReport::DTN === $report->getFrom()) {
if (!$accessRuleService->hashRightToResponseReport($report) && !$accessRuleService->isAdmin()) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
} elseif (DemandeReport::MANAGER === $report->getFrom() || DemandeReport::ADMIN === $report->getFrom()) {
$this->setWorkflow($report);
}
$entityManager = $this->doctrine->getManager();
$entityManager->flush();
if ($report->getResponse() && !is_null($report->getId())) {
$role = $this->getUser()->getUtilisateur()->getIdRole();
if (in_array($role, Utilisateur::MANAGER)) {
$this->initSignatureConges($report->getId());
}
}
$result = ["success" => true];
$response = JsonResponse::HTTP_OK;
} else {
$result = [
'success' => false,
'data' => self::ERROR_VALIDATION_FORM,
'error' => (string) $form->getErrors(true, false)
];
$response = JsonResponse::HTTP_BAD_REQUEST;
}
return new JsonResponse($result, $response);
}
/**
* @return JsonResponse
*/
#[Route(path: '/api/report/generate-to-print', name: 'ctsweb_print_report', methods: ['POST'])]
public function generateToPrint(Request $request)
{
$accessRuleService = $this->getServiceAccessRule();
if (!$accessRuleService->hasRightForTakingDayOff()) {
return new JsonResponse('', JsonResponse::HTTP_FORBIDDEN);
}
$report = new DemandeReport();
$form = $this->handleRequest($request, $report, 'all', 'post');
$em = $this->doctrine->getManager();
$repository = $em->getRepository(DemandeReport::class);
try {
if ($form->isSubmitted() && $form->isValid()) {
$entityManager = $this->doctrine->getManager();
$report->setUtilisateur($this->getUser()->getUtilisateur());
$serviceGeneratePdf = $this->generatePdf;
$entityManager->persist($report);
$content = $serviceGeneratePdf->generateReportPdf($report, true);
$filename = sha1($report->getId()) . '.pdf';
$response = $this->getResponse($content, $filename);
} else {
$response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
}
} catch (\Exception) {
$response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
}
return $response;
}
/**
* @return Response
*/
#[Route(path: '/api/report/pdf/{id}', name: 'ctsweb_reports_generate-pdf', methods: ['GET'], requirements: ['id' => '\d+'])]
public function pdf(DemandeReport $report)
{
if (
Workflow::RE_REJECT === $report->getWorkflow()->getIdWorkflow()
|| Workflow::RE_SIGN === $report->getWorkflow()->getIdWorkflow()
) {
$filename = sha1($report->getId()) . '.pdf';
$path = $this->getParameter('dir_file_report') . $filename;
if (file_exists($path)) {
$content = file_get_contents($path, FILE_USE_INCLUDE_PATH);
$response = $this->getResponse($content, $filename);
} else {
$response = new JsonResponse(['error' => self::ERROR_FILE], JsonResponse::HTTP_BAD_REQUEST);
}
} else {
$serviceGeneratePdf = $this->generatePdf;
$content = $serviceGeneratePdf->generateReportPdf($report, false);
$filename = sha1($report->getId()) . '.pdf';
$response = $this->getResponse($content, $filename);
}
return $response;
}
#[Route(path: '/api/report/status/list', name: 'ctsweb_reports_status-list-pdf', methods: ['GET'], requirements: ['id' => '\d+'])]
public function statusList(): JsonResponse
{
$entityManager = $this->doctrine->getManager();
$statuses = $entityManager
->getRepository(Workflow::class)
->findBy(['idWorkflow' => Workflow::FILTER]);
return new JsonResponse(
$this->serialize($statuses),
JsonResponse::HTTP_OK,
[],
true
);
}
#[Route(path: '/api/report/access/{conge}', name: 'ctsweb_reports_access', methods: ['GET'], requirements: ['conge' => '\d+'])]
public function accesreport(utilisateur $conge)
{
$entityManager = $this->doctrine->getManager();
$user = $this->getUser();
$utilisateur = $conge->getidUtilisateur();
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $utilisateur]);
$Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
$affectation = $entityManager
->getRepository(RefAffectation::class)
->findOneBy(["idAffectation" => $Idaffectation]);
$getRefCalendrier = $entityManager
->getRepository(RefAffectationCalendrier::class)
->getRefCalendrier($Idaffectation);
$congeScolaire = $getRefCalendrier['calendrierScolaire'];
$year = $this->getYear($user);
$statuses = $entityManager
->getRepository(DemandeReport::class)
->accessReport($year, $user, $congeScolaire);
return new JsonResponse(
$this->serialize($statuses),
JsonResponse::HTTP_OK,
[],
true
);
}
/**
* @return \Symfony\Component\Form\FormInterface
*/
private function handleRequest(
Request $request,
DemandeReport $report,
string $label,
string $validationGroup
) {
$data = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
$request->request->replace(is_array($data) ? $data : []);
$form = $this->createForm(
DemandeReportType::class,
$report,
['label' => $label, 'validation_groups' => $validationGroup]
);
$form->handleRequest($request);
return $form;
}
/**
* @param array $states
* @return mixed
*/
private function serializeto($item)
{
$data = [$item];
$context = new SerializationContext();
$context->setSerializeNull(true);
return $this->serializer->serialize($data, 'json', $context);
}
/**
* @param array $states
* @return mixed
*/
private function serialize($item)
{
$data = ["items" => $item];
$context = new SerializationContext();
$context->setSerializeNull(true);
return $this->serializer->serialize($data, 'json', $context);
}
/**
* @return object
*/
private function getServiceAccessRule()
{
return $this->accessRule;
}
private function setWorkflow(DemandeReport $report)
{
$workflow = Workflow::RE_REJECT;
if ($report->getResponse()) {
$workflow = Workflow::RE_SIGN;
}
$entityManager = $this->doctrine->getManager();
$workflowEntity = $entityManager
->getRepository(Workflow::class)
->find($workflow);
$report->setWorkflow($workflowEntity);
}
public function getResponse(string $content, string $filename): Response
{
return new Response(
$content,
Response::HTTP_OK,
[
'Content-Type' => 'application/pdf',
'Content-Length' => strlen($content),
'Content-Disposition' => "attachment;filename=\"{$filename}",
'Accept-Ranges' => 'bytes'
]
);
}
public function initSignatureConges($idconges)
{
try {
// $listeConges = explode(',', $request->request->get('listeConges'));
// $listeConges = json_decode($request->getContent(), true);
$em = $this->doctrine->getManager();
$reportsRepo = $em->getRepository(DemandeReport::class);
$workflow = $em->getRepository(Workflow::class)->find(Workflow::RE_SIGN);
$jourdhui = (new \DateTime())->format('Y-m-d');
$utilisateurRepository = $em->getRepository(Utilisateur::class);
$congObj = $reportsRepo->find($idconges);
$idUtilisateur = $congObj->getUtilisateur()->getIdUtilisateur();
$affectation = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($idUtilisateur)->getIdAffectation()->getIdAffectation();
if ($affectation != 1) {
$drsignataire = $em->getRepository(UtilisateurInformation::class)->findDrSuperieur($affectation);
} else {
$drsignataire = $em->getRepository(UtilisateurInformation::class)->findDsSuperieur($affectation);
}
$signataire = $em->getRepository(UtilisateurInformation::class)->findOneByIdUtilisateur($drsignataire);
$info_signature = array(
'nom' => $signataire->getNom(),
'prenom' => $signataire->getPrenom(),
'dateSignature' => date("d/m/Y"),
'sup' => true,
'fonction' => $signataire->getFonction(),
'path' => $signataire->getScan() ? $this->getParameter('dir_file_signature') . $signataire->getScan()->getAbsolutePath() : '',
'civilite' => $signataire->getCivilite()
);
// foreach ($listeConges as $report) {
$congObj = $reportsRepo->find($idconges);
$congObj->setWorkflow($workflow);
$idUtilisateur = $congObj->getUtilisateur()->getIdUtilisateur();
$email = $utilisateurRepository->findCourrielById($idUtilisateur)[0]['courriel'];
$mail = $this->emailSHDecision->getMail(
EmailSHDecision::SIGNED,
EmailSHDecision::RE,
$email,
);
if ($mail) {
$this->mailer->send($mail);
}
// $info_signature['dateSignature']=$congObj->getDateDerniereModification();
// $em->setDateDeSignature($jourdhui);
// $em->setSignataire($signataire);
$em->persist($congObj);
$em->flush();
// UPDATE ET CREE RAA dans la table conge_droit_annuel
$this->createUpdateRAA($congObj);
$this->generatePdf->generateReportPdf($congObj, false, $affectation, $info_signature);
// }
$message = 'Tous les demandes de report ont été signés avec succès.';
$return = array(
'success' => true,
'data' => $message
);
} catch (\Exception $e) {
$message = 'Un ou plusieurs reports n\'ont pu être signés.';
$return = array(
'success' => false,
'data' => $e->getMessage()
);
}
return new JsonResponse(
$return,
JsonResponse::HTTP_CREATED
);
}
public function createUpdateRAA(DemandeReport $report)
{
$entityManager = $this->doctrine->getManager();
$congeDroitAnnuelRepository = $entityManager->getRepository(CongeDroitAnnuel::class);
$raaId = 4;
$raa = $entityManager->find(CongeType::class, $raaId);
if (!$raa) {
throw new \Exception("Impossible de trouver l'entité CongeType avec l'ID $raaId.");
}
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $report->getUtilisateur()]);
$Idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
$getRefCalendrier = $entityManager
->getRepository(RefAffectationCalendrier::class)
->getRefCalendrier($Idaffectation);
$dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
$congeScolaire = $getRefCalendrier['calendrierScolaire'];
$dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
$today = (new \DateTime());
$year = $today->format("Y");
if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
$Annee = $year;
}
else{
$Annee = $year+1 ;
}
$Type_cal = ($getRefCalendrier['calendrierAffectation']) ? 's' : 'c';
$existingCongeDroitAnnuel = $congeDroitAnnuelRepository->findOneBy([
'congeType' => $raa,
'utilisateur' => $report->getUtilisateur(),
'annee' => $Annee,
'typeCalendrier' =>$Type_cal,
]);
if (!$existingCongeDroitAnnuel) {
// create
$newCongeDroitAnnuel = new CongeDroitAnnuel();
$newCongeDroitAnnuel->setCongeType($raa);
$newCongeDroitAnnuel->setUtilisateur($report->getUtilisateur());
$newCongeDroitAnnuel->setAnnee($Annee);
$newCongeDroitAnnuel->setTypeCalendrier($Type_cal);
$newCongeDroitAnnuel->setNbJourTotal($report->getNbJour());
$newCongeDroitAnnuel->setArchive(false);
$entityManager->persist($newCongeDroitAnnuel);
$entityManager->flush();
return true;
} else {
// Update
$existingCongeDroitAnnuel->setNbJourTotal($report->getNbJour());
$entityManager->flush();
return true;
}
}
public function getYear($user)
{
$entityManager = $this->doctrine->getManager();
// Récupérer les informations de l'utilisateur
$Idaffectation = $user->getIdAffectation()->getIdAffectation();
$today = (new \DateTime());
$year = $today->format("Y");
$getRefCalendrier = $entityManager
->getRepository(RefAffectationCalendrier::class)
->getRefCalendrier($Idaffectation);
$congeScolaire = $getRefCalendrier['calendrierScolaire'];
$dateBasculeCongeSolaire = $getRefCalendrier['dateBascule'];
if ((true === $congeScolaire) && ($dateBasculeCongeSolaire < $today) && ($today < new \DateTime("$year-09-01"))) {
return $year - 1;
} else {
return $year;
}
return $year;
}
public function getAnneeSaisie(
int $id,
int $n
) {
$congesDroitsAnnees = [];
$entityManager = $this->doctrine->getManager();
$utilisateurInformation = $entityManager
->getRepository(UtilisateurInformation::class)
->findOneBy(["idUtilisateur" => $id]);
// $affectation = $utilisateurInformation->getIdAffectation();
// $congeScolaire = $affectation->getCalendrierScolaire();
// $dateBascule = $affectation->getDateBascule();
$idaffectation = $utilisateurInformation->getIdAffectation()->getIdAffectation();
$getRefCalendrier = $entityManager
->getRepository(RefAffectationCalendrier::class)
->getRefCalendrier($idaffectation);
$congeScolaire = $getRefCalendrier['calendrierScolaire'];
$dateBascule = $getRefCalendrier['dateBascule'];
$today = new \DateTime();
$currentYear = $today->format('Y');
if ($n == 0) {
$year = $currentYear - 1;
$currentDay = $today;
} else {
$year = $currentYear;
$currentDay = $today;
}
$currentDay = $currentDay->format('Y-m-d');
$nextYear = $year + 1;
$lastYear = $year - 1;
if ((true == $congeScolaire) && (null != $dateBascule) && ($currentDay >= $dateBascule)) {
if ($n == 1) {
$congesDroitsAnnees['libelle'] = $lastYear . "/" . $year;
} else {
$congesDroitsAnnees['libelle'] = strval($year);
}
} elseif ((true == $congeScolaire) && (null != $dateBascule) && ($currentDay < $dateBascule)) {
$congesDroitsAnnees['libelle'] = strval($year);
} elseif ((false == $congeScolaire) && (null != $dateBascule) && ($currentDay <= $dateBascule)) {
$congesDroitsAnnees['libelle'] = $lastYear . "/" . $year;
} else {
$congesDroitsAnnees['libelle'] = strval($year);
}
return $congesDroitsAnnees;
}
}

src/Controller/DemandeReportController.php line 612