src/Controller/SocietyController.php line 80

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Associes;
  6. use App\Entity\ClauseScoiety;
  7. use App\Entity\Client;
  8. use App\Entity\DomiciliationAddress;
  9. use App\Entity\DocumentSociety;
  10. use App\Entity\Files;
  11. use App\Entity\President;
  12. use App\Entity\Signatures;
  13. use App\Entity\SirenEnterprise;
  14. use App\Entity\Society;
  15. use App\Entity\UserClauseSelection;
  16. use App\Entity\UserSocietyActivities;
  17. use App\Events\DocumentEvent;
  18. use App\Form\AssociesType;
  19. use App\Form\PresidentType;
  20. use App\Form\SocietyConditionsType;
  21. use App\Form\SocietyIndicatorType;
  22. use App\Form\SocietyType;
  23. use App\Manager\InpiManager;
  24. use App\Repository\ClauseScoietyRepository;
  25. use App\Repository\ClientRepository;
  26. use App\Repository\DocumentSocietyRepository;
  27. use App\Repository\FilesRepository;
  28. use App\Repository\IbanRepository;
  29. use App\Repository\SirenEnterpriseRepository;
  30. use App\Repository\SocietyRepository;
  31. use App\Repository\UserClauseSelectionRepository;
  32. use App\Repository\UserRepository;
  33. use App\Service\MailService;
  34. use App\Service\S3Service;
  35. use Doctrine\ORM\EntityManagerInterface;
  36. use Knp\Component\Pager\PaginatorInterface;
  37. use Psr\EventDispatcher\EventDispatcherInterface;
  38. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  39. use Symfony\Component\EventDispatcher\GenericEvent;
  40. use Symfony\Component\HttpClient\HttpClient;
  41. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  42. use Symfony\Component\HttpFoundation\JsonResponse;
  43. use Symfony\Component\HttpFoundation\RedirectResponse;
  44. use Symfony\Component\HttpFoundation\Request;
  45. use Symfony\Component\HttpFoundation\RequestStack;
  46. use Symfony\Component\HttpFoundation\Response;
  47. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  48. use Symfony\Component\Routing\Annotation\Route;
  49. use PhpOffice\PhpWord\Shared\ZipArchive;
  50. use Symfony\Component\Security\Core\Security;
  51. use Symfony\Contracts\HttpClient\HttpClientInterface;
  54. /**
  55.  * @Route("/society")
  56.  */
  57. class SocietyController extends AbstractController
  58. {
  60.     private $mailService;
  61.     private $documentSocietyRepository;
  62.     private $entityManager;
  63.     private $s3Service;
  65.     private $httpClient;
  69.     public function __construct(MailService $mailService, DocumentSocietyRepository $documentSocietyRepository, EntityManagerInterface $entityManager, S3Service $s3Service , HttpClientInterface $httpClient)
  70.     {
  71.         $this->mailService = $mailService;
  72.         $this->documentSocietyRepository = $documentSocietyRepository;
  73.         $this->entityManager = $entityManager;
  74.         $this->s3Service = $s3Service;
  75.         $this->httpClient = $httpClient;    }
  77.     /**
  78.      * @Route("/", name="society_index", methods={"GET"})
  79.      */
  80.     public function index(Request $request, PaginatorInterface $paginator, SocietyRepository $societyRepository, UserRepository $userRepository)
  81.     {
  82.         $connectedUser = $this->getUser();
  83.         if (!$connectedUser) {
  84.             throw $this->createAccessDeniedException('Vous devez être connecté pour accéder à cette page.');
  85.         }
  87.         $collaborator = $request->query->getInt('collaborator') ?: null;
  88.         $postalCode   = trim(strip_tags((string) $request->query->get('postal_code', ''))) ?: null;
  89.         $address      = trim(strip_tags((string) $request->query->get('address', ''))) ?: null;
  90.         $name         = trim(strip_tags((string) $request->query->get('name', ''))) ?: null;
  91.         $number       = trim(strip_tags((string) $request->query->get('number', ''))) ?: null;
  92.         $created      = trim(strip_tags((string) $request->query->get('created', ''))) ?: null;
  94.         $users = [];
  95.         $collaborators = [];
  96.         $isClient = false;
  97.         $isCollaborator = false;
  99.         if ($this->isGranted('ROLE_ADMIN')) {
  100.             $users = $userRepository->findAll();
  101.         } elseif ($this->isGranted('ROLE_CLIENT')) {
  102.             $users = $userRepository->findCollaboratorsByClient($connectedUser);
  103.             $collaborators = array_map(function ($user) {
  104.                 return $user->getId();
  105.             }, $users);
  106.             $isClient = true;
  107.         } elseif ($this->isGranted('ROLE_COLLABORATEUR')) {
  108.             // If the user is a collaborator, show only their own societies
  109.             $collaborators = [$connectedUser->getId()];
  110.             $isCollaborator = true;
  111.         }
  113.         $queryBuilder = $societyRepository->findByFiltersQueryBuilder(
  114.             $collaborator, $postalCode, $address, $name, $number, $connectedUser->getClient(), $collaborators, $isClient, $isCollaborator, $created
  115.         );
  117.         // Pagination côté serveur avec Knp Paginator
  118.         $pagination = $paginator->paginate(
  119.             $queryBuilder,
  120.             $request->query->getInt('page', 1),
  121.             12 // Nombre d'items par page
  122.         );
  124.         // Calcul des statistiques significatives
  125.         $allSocieties = $queryBuilder->getQuery()->getResult();
  127.         // Sociétés créées ce mois
  128.         $startOfMonth = new \DateTime('first day of this month 00:00:00');
  129.         $createdThisMonth = array_filter($allSocieties, function($society) use ($startOfMonth) {
  130.             return $society->getCreated() && $society->getCreated() >= $startOfMonth;
  131.         });
  133.         // Sociétés modifiées dans les 7 derniers jours
  134.         $sevenDaysAgo = new \DateTime('-7 days');
  135.         $recentlyUpdated = array_filter($allSocieties, function($society) use ($sevenDaysAgo) {
  136.             return $society->getUpdated() && $society->getUpdated() >= $sevenDaysAgo;
  137.         });
  139.         // Sociétés en attente (status = 'created')
  140.         $pendingSocieties = array_filter($allSocieties, function($society) {
  141.             return $society->getStatus() === Society::STATUS_CREATED;
  142.         });
  144.         return $this->render('society/index.html.twig', [
  145.             'pagination' => $pagination,
  146.             'users' => $users,
  147.             'stats' => [
  148.                 'createdThisMonth' => count($createdThisMonth),
  149.                 'recentlyUpdated' => count($recentlyUpdated),
  150.                 'pending' => count($pendingSocieties),
  151.             ],
  152.         ]);
  153.     }
  156.     /**
  157.      * @Route("/new", name="society_new", methods={"GET", "POST"})
  158.      */
  159.     public
  160.     function new(Request $request, EntityManagerInterface $entityManager, RequestStack $requestStack): Response
  161.     {
  162.         $society = new Society();
  164.         $user = $this->getUser();
  165.         /**
  166.          * @var Client $client
  167.          */
  168.         $client = $user->getClient();
  170.         // Pré-remplir les infos de domiciliation depuis le client existant
  171.         if ($client) {
  172.             $domClient = new \App\Entity\Client();
  173.             $domClient->setName($client->getName());
  174.             $domClient->setSocietyForme($client->getSocietyForme());
  175.             $domClient->setSiren($client->getSiren());
  176.             $domClient->setAgreementNumber($client->getAgreementNumber());
  177.             $domClient->setSocietySiege($client->getSocietySiege());
  178.             $domClient->setCp($client->getCp());
  179.             $domClient->setVille($client->getVille());
  180.             $domClient->setSocietyCapitalChiffre($client->getSocietyCapitalChiffre());
  181.             $domClient->setSocietyCapitalLettre($client->getSocietyCapitalLettre());
  182.             $domClient->setQualityRepresentant($client->getQualityRepresentant());
  183.             $domClient->setCivility($client->getCivility());
  184.             $domClient->setRepresantantLastName($client->getRepresantantLastName());
  185.             $domClient->setRepresantantFirstName($client->getRepresantantFirstName());
  186.             $domClient->setDescriptionService($client->getDescriptionService());
  187.             $domClient->setImmeubleDescription($client->getImmeubleDescription());
  188.             $domClient->setEquipment($client->getEquipment());
  189.             $domClient->setSurfaceOffice($client->getSurfaceOffice());
  190.             $domClient->setPieceNumber($client->getPieceNumber());
  191.             $domClient->setMontantRedevance($client->getMontantRedevance());
  192.             $domClient->setDureeContrat($client->getDureeContrat());
  193.             $domClient->setDelaiDay($client->getDelaiDay());
  194.             $society->setClient($domClient);
  195.         }
  197.         $form = $this->createForm(SocietyType::class, $society);
  198.         $form->handleRequest($request);
  199.         $formAssocy = $this->createForm(AssociesType::class);
  200.         $client->getSociety()->count();
  201.         if ($form->isSubmitted() && $form->isValid()) {
  202.             $number = sprintf("%08d", $client->getSociety()->count() + 1);
  203.             $society->setCreated(new \DateTime("now"));
  204.             $society->setClient($user->getClient());
  205.             $society->setStatus(Society::STATUS_CREATED);
  206.             $society->setNumber(sprintf('%08d', $number));
  207.             $society->setUser($user);
  208.             $society->setFreeOrder(true);
  210.             // Store the selected domiciliation address reference
  211.             $domiciliationAddressId = $request->request->get('domiciliation_address_id');
  212.             if ($domiciliationAddressId) {
  213.                 $domiciliationAddress = $entityManager->getRepository(DomiciliationAddress::class)->find($domiciliationAddressId);
  214.                 if ($domiciliationAddress && $domiciliationAddress->getClient() === $client) {
  215.                     $society->setDomiciliationAddress($domiciliationAddress);
  216.                 }
  217.             }
  219.             $entityManager->persist($society);
  220.             $entityManager->flush();
  221.             $publicDirectory = $this->getParameter('pdf_directory');
  222.             $filepath = $publicDirectory . "/" . $society->getId() . "/";
  223.             if (!file_exists($filepath)) {
  224.                 mkdir($filepath, 0777, true);
  225.             }
  226.             $requestStack->getSession()->set('tab', 'society');
  227.             $entityManager->flush();
  228.             return $this->redirectToRoute('society_show', ['id' => $society->getId()], Response::HTTP_SEE_OTHER);
  229.         }
  231.         $domiciliationAddresses = $client->getDomiciliationAddresses();
  233.         $yearEnd = date('j/m', strtotime('12/31'));
  234.         $now = new \DateTime();
  235.         return $this->renderForm('society/new.html.twig', [
  236.             'society' => $society,
  237.             'endDate' => $yearEnd,
  238.             'now' => date('j/m/Y'),
  239.             'form' => $form,
  240.             'formAssocy' => $formAssocy,
  241.             'client' => $user,
  242.             'domiciliationAddresses' => $domiciliationAddresses,
  243.         ]);
  244.     }
  246.     /**
  247.      * @Route("/api/domiciliation-address/{id}", name="api_domiciliation_address", methods={"GET"})
  248.      */
  249.     public function getDomiciliationAddress(int $id, EntityManagerInterface $entityManager): JsonResponse
  250.     {
  251.         $user = $this->getUser();
  252.         $client = $user->getClient();
  254.         $address = $entityManager->getRepository(DomiciliationAddress::class)->find($id);
  256.         if (!$address || $address->getClient() !== $client) {
  257.             return new JsonResponse(['error' => 'Adresse non trouvée'], Response::HTTP_NOT_FOUND);
  258.         }
  260.         return new JsonResponse([
  261.             'id' => $address->getId(),
  262.             'label' => $address->getLabel(),
  263.             'name' => $address->getName(),
  264.             'societyForme' => $address->getSocietyForme(),
  265.             'siren' => $address->getSiren(),
  266.             'agreementNumber' => $address->getAgreementNumber(),
  267.             'societySiege' => $address->getSocietySiege(),
  268.             'cp' => $address->getCp(),
  269.             'ville' => $address->getVille(),
  270.             'societyCapitalChiffre' => $address->getSocietyCapitalChiffre(),
  271.             'societyCapitalLettre' => $address->getSocietyCapitalLettre(),
  272.             'qualityRepresentant' => $address->getQualityRepresentant(),
  273.             'civility' => $address->getCivility(),
  274.             'represantantLastName' => $address->getRepresantantLastName(),
  275.             'represantantFirstName' => $address->getRepresantantFirstName(),
  276.             'descriptionService' => $address->getDescriptionService(),
  277.             'immeubleDescription' => $address->getImmeubleDescription(),
  278.             'equipment' => $address->getEquipment(),
  279.             'surfaceOffice' => $address->getSurfaceOffice(),
  280.             'pieceNumber' => $address->getPieceNumber(),
  281.             'montantRedevance' => $address->getMontantRedevance(),
  282.             'domiciliationDate' => $address->getDomiciliationDate() ? $address->getDomiciliationDate()->format('Y-m-d') : null,
  283.             'dureeContrat' => $address->getDureeContrat(),
  284.             'delaiDay' => $address->getDelaiDay(),
  285.         ]);
  286.     }
  288.     /**
  289.      * @Route("/searchSiren", name="society_siren_info")
  290.      */
  291.     public function fetchEnterpriseData(SirenEnterpriseRepository $sirenEnterpriseRepository, EntityManagerInterface $entityManager, Request $request)
  292.     {
  294.         $siren = $request->request->get('siren');
  295.         $enterprise = $sirenEnterpriseRepository->findOneBy(['siren' => $siren]);
  297.         if ($enterprise) {
  298.             $html = $this->renderView('society/enterpriseInfo.html.twig', ['data' => $enterprise->getData(), 'siren' => $siren]);
  299.             return new Response($html);
  300.         }
  301.         $apiToken = 'fa81590fc90352718e3dd057c27a9f34cd57188d83fd002f';
  302.         $url = "https://api.pappers.fr/v2/entreprise?api_token=$apiToken&siren=$siren";
  304.         $httpClient = HttpClient::create();
  305.         $response = $httpClient->request('GET', $url);
  306.         $data = [];
  307.         $apiError = null;
  308.         $statusCode = $response->getStatusCode();
  309.         if ($statusCode === 200) {
  310.             $content = $response->getContent();
  312.             $data = json_decode($content, true);
  313.             $enterprise = new SirenEnterprise();
  314.             $enterprise->setSiren($siren);
  315.             $enterprise->setData($data);
  316.             $entityManager->persist($enterprise);
  317.             $entityManager->flush();
  319.         } else {
  320.             $content = $response->getContent(false);
  321.             $errorData = json_decode($content, true);
  322.             if (isset($errorData['error'])) {
  323.                 $apiError = $errorData['error'];
  324.             }
  325.         }
  326.         //normalement data hna fil edit njib associe ou bien dirigent -> getRepresentantData mech donnés mta3 l api, 5ater badel fihom
  327.         $html = $this->renderView('society/enterpriseInfo.html.twig', ['data' => $data, 'siren' => $siren, 'apiError' => $apiError]);
  328.         return new Response($html);
  329.     }
  332.     /**
  333.      * @Route("/{id}", name="society_show", methods={"GET"})
  334.      */
  335.     public function show(Society $society, ClauseScoietyRepository $clauseScoietyRepository, IbanRepository $ibanRepository, FilesRepository $filesRepository, EntityManagerInterface $entityManager, Request $request, InpiManager $inpiManager, Security $security, UserClauseSelectionRepository $userClauseSelectionRepository, RequestStack $requestStack): Response
  336.     {
  338.         $user = $security->getUser();
  339.         if ($society->getUser() !== $user) {
  341.             return $this->render('redirection/AccessDenied.html.twig');
  342.         }
  343.         $selectedProfile = null;
  344.         $statutsBySocietyType = null;
  345.         if ($society->getType()) {
  346.             $statutsBySocietyType = $userClauseSelectionRepository->StatusSociety($user->getId(), $society->getType()->getId());
  347.             if ($society->getSelectedProfil()) {
  348.                 $selectedProfile = $society->getSelectedProfil()->getClauses();
  349.             }
  350.         }
  352.         $actifTabParam = $request->query->get('actifTab');
  353.         if ($actifTabParam === 'signature') {
  354.             $actifTab = 'signature';
  355.         } else {
  356.             $tab = $requestStack->getSession()->get('tab');
  357.             if ($tab && $tab == 'society') {
  358.                 $actifTab = 'society';
  359.             } else
  360.                 $actifTab = 'document';
  361.             if (count($society->getDocumentSocieties()) > 0) {
  362.                 $requestStack->getSession()->remove('tab');
  363.             }else{
  364.                 $actifTab = 'society';
  365.             }
  366.         }
  367.         $form = $this->createForm(SocietyType::class, $society);
  368.         $formSocietyIndicator = $this->createForm(SocietyIndicatorType::class);
  369.         // Formulaire "Nouvel associé" : doit être vide pour saisir un nouvel associé.
  370.         // (Auparavant lié au 1er associé existant -> le formulaire s'affichait pré-rempli.)
  371.         $formAssocy = $this->createForm(AssociesType::class, new Associes(), ['pourcentageMax' => $society->getTotalPourcentageAssocies()]);
  372.         $formPresident = $this->createForm(PresidentType::class,new President());
  373.         //dd($formPresident);
  374.         $SocietyConditions = $society->getSocietyConditions() ? $society->getSocietyConditions() : null;
  375.         $formSocietyConditions = $this->createForm(SocietyConditionsType::class, $SocietyConditions);
  376.         $form->handleRequest($request);
  377.         $files = $filesRepository->findBy(['society' => $society->getId()]);
  378.         $documents = $society->getDocumentSocieties();
  379.         //$signatairesByDocument = [];
  380.         //foreach ($documents as $document) {
  381.         //$signatairesByDocument[$document->getId()] = $document->getSociety()->getSignataires() ?? [];
  382.         //}
  384.         mb_internal_encoding("UTF-8"); // Assurez-vous que l'encodage interne est défini sur UTF-8
  385.         $societyTypeName = $society->getType() ? $society->getType()->getName() : "NC";
  386.         $decodedName = mb_convert_case($societyTypeName, MB_CASE_LOWER, "UTF-8");
  387.         $includeCommon = !str_contains($decodedName, 'sasu');
  388.         $statuts = $clauseScoietyRepository->findBySocietyType(trim($decodedName), $includeCommon);
  389.         $recipients = $society->getAssociesEmails();
  390.         //b$documentsSigned = $entityManager->getRepository(Signatures::class)->findBy(['status' => $society->getId(), 'si' => ['!=' => null]]);
  392.         // Aligne la BDD sur les auto-checks visuels de helpers.html.twig (lignes ~391-396) et
  393.         // _formEdit.html.twig (ligne ~1446). Sans ça, certaines conditions sont cochées à l'écran
  394.         // (parfois masquées en display:none) mais absentes de societyStatus, ce qui empêche les
  395.         // sous-champs AJAX (AGE LIMITE, DELAI PREAVIS, etc.) d'apparaître.
  396.         $status = $society->getSocietyStatus() ?? [];
  397.         $changed = false;
  399.         // Cas 1 : au moins un président enregistré → PRESIDENT_DE_LA_SOCIETE_SASU + organe_dirigeant_unique_president
  400.         $hasPresidentQuality = !$society->getPresidents()->isEmpty();
  401.         if ($hasPresidentQuality) {
  402.             foreach (['PRESIDENT_DE_LA_SOCIETE_SASU', 'organe_dirigeant_unique_president'] as $ref) {
  403.                 if (!in_array($ref, $status, true)) {
  404.                     $status[] = $ref;
  405.                     $changed = true;
  406.                 }
  407.             }
  408.         }
  410.         // Cas 2 : DIRECTEURS_GENERAL_AUX_SASU coché → dispositions_statutaires_designation_dg
  411.         // (condition masquée display:none par helpers.html.twig:385 mais auto-cochée par le hack 394-396)
  412.         if (in_array('DIRECTEURS_GENERAL_AUX_SASU', $status, true)
  413.             && !in_array('dispositions_statutaires_designation_dg', $status, true)) {
  414.             $status[] = 'dispositions_statutaires_designation_dg';
  415.             $changed = true;
  416.         }
  418.         // Cas 3 : au moins un président avec isRepresanteSociety=true → dg_pouvoir_representer_societe
  419.         $hasPresidentRepresenting = false;
  420.         foreach ($society->getPresidents() as $p) {
  421.             if ($p->getIsRepresanteSociety()) {
  422.                 $hasPresidentRepresenting = true;
  423.                 break;
  424.             }
  425.         }
  426.         if ($hasPresidentRepresenting
  427.             && !in_array('dg_pouvoir_representer_societe', $status, true)) {
  428.             $status[] = 'dg_pouvoir_representer_societe';
  429.             $changed = true;
  430.         }
  432.         if ($changed) {
  433.             $society->setSocietyStatus(array_values($status));
  434.             $entityManager->persist($society);
  435.             $entityManager->flush();
  436.         }
  438.         return $this->render('society/show.html.twig', [
  439.             'society' => $society,
  440.             'recipients' => $recipients,
  441.             'documents' => $documents,
  442.             'signataires' => $society->getSignataires(),
  443.             'form' => $form->createView(),
  444.             'formAssocy' => $formAssocy->createView(),
  445.             'formSocietyConditions' => $formSocietyConditions->createView(),
  446.             'formPresident' => $formPresident->createView(),
  447.             'formSocietyIndicator' => $formSocietyIndicator->createView(),
  448.             'associes' => $society->getAssocies(),
  449.             'presidents' => $society->getPresidents(),
  450.             'society_indicators' => $society->getSocietyIndicators(),
  451.             'files' => $files,
  452.             'directory' => "uploads/societyDocuments/",
  453.             'statuts' => $statuts,
  454.             'statutsBySocietyType' => $statutsBySocietyType,
  455.             'selectedProfile' => $selectedProfile,
  456.             'actifTab' => $actifTab,
  457.             'domiciliationAddresses' => $user->getClient() ? $user->getClient()->getDomiciliationAddresses() : [],
  459.         ]);
  460.     }
  462.     /**
  463.      * @Route("/api/society/{id}/can-update", name="api_society_can_update", methods={"GET"})
  464.      */
  465.     public function canUpdateSocietyApi(int $id, EntityManagerInterface $em): JsonResponse
  466.     {
  467.         $society = $em->getRepository(Society::class)->find($id);
  469.         if (!$society) {
  470.             return new JsonResponse(['error' => 'Société introuvable'], 404);
  471.         }
  473.         $associes = count($society->getAssocies());
  474.         $dirigeants = count($society->getPresidents());
  476.         $canUpdate = $associes > 0 && $dirigeants > 0;
  477.         return new JsonResponse(['canUpdate' => $canUpdate]);
  478.     }
  481.     /**
  482.      * @Route("/{id}/edit", name="society_edit", methods={"GET", "POST"})
  483.      */
  484.     public function edit(Request $request, Society $society, EntityManagerInterface $entityManager, FilesRepository $filesRepository, EventDispatcherInterface $dispatcher): Response
  485.     {
  486.         $form = $this->createForm(SocietyType::class, $society);
  487.         $form->handleRequest($request);
  488.         $publicDirectory = $this->getParameter('pdf_directory');
  489.         $filepath = $publicDirectory . "/" . $society->getId() . "/";
  490.         if (!file_exists($filepath)) {
  491.             mkdir($filepath, 0777, true);
  492.         }
  493.         if ($form->isSubmitted()) {
  495.             // Sauvegarder les champs condition_* des formulaires AJAX dans societyStatus
  496.             $allParams = $request->request->all();
  497.             $societyStatus = $society->getSocietyStatus() ?? [];
  498.             foreach ($allParams as $key => $value) {
  499.                 if (strpos($key, 'condition_') === 0 && !empty($value)) {
  500.                     $societyStatus[$key] = $value;
  501.                 }
  502.             }
  503.             // Filtrer les Commissaire vides (aucun champ significatif rempli) avant flush
  504.             foreach ($society->getCommissaires() as $commissaire) {
  505.                 if (empty($commissaire->getType())
  506.                     && empty($commissaire->getNom())
  507.                     && empty($commissaire->getPrenom())
  508.                     && empty($commissaire->getSiren())
  509.                     && empty($commissaire->getDenomination())
  510.                     && empty($commissaire->getDescription())) {
  511.                     $society->removeCommissaire($commissaire);
  512.                     $entityManager->remove($commissaire);
  513.                 }
  514.             }
  515.             // Auto-cocher COMMISSAIRES_AUX_COMPTES_SASU si au moins un commissaire reste apres filtrage
  516.             $hasCommissaire = false;
  517.             foreach ($society->getCommissaires() as $commissaire) {
  518.                 if (!empty($commissaire->getType())) {
  519.                     $hasCommissaire = true;
  520.                     break;
  521.                 }
  522.             }
  523.             if ($hasCommissaire && !in_array('COMMISSAIRES_AUX_COMPTES_SASU', $societyStatus, true)) {
  524.                 $societyStatus[] = 'COMMISSAIRES_AUX_COMPTES_SASU';
  525.             }
  526.             $society->setSocietyStatus($societyStatus);
  528.             // Sauvegarder les champs capitalVariable / capitalMontantMin / capitalMontantMax sur le premier associé
  529.             $associesPostData = $request->request->all('associes');
  530.             if (!empty($associesPostData)) {
  531.                 $firstAssocy = $society->getAssocies()->first();
  532.                 if ($firstAssocy) {
  533.                     $firstAssocy->setCapitalVariable(!empty($associesPostData['capitalVariable']));
  534.                     $firstAssocy->setCapitalMontantMin($associesPostData['capitalMontantMin'] ?? null);
  535.                     $firstAssocy->setCapitalMontantMax($associesPostData['capitalMontantMax'] ?? null);
  536.                     if (!empty($associesPostData['Periodicite'])) {
  537.                         $firstAssocy->setPeriodicite($associesPostData['Periodicite']);
  538.                     }
  539.                     $entityManager->persist($firstAssocy);
  540.                 }
  541.             } else {
  542.                 // Checkbox non cochée = décochée
  543.                 $firstAssocy = $society->getAssocies()->first();
  544.                 if ($firstAssocy) {
  545.                     $firstAssocy->setCapitalVariable(false);
  546.                     $entityManager->persist($firstAssocy);
  547.                 }
  548.             }
  550.             // Store the selected domiciliation address reference
  551.             $domiciliationAddressId = $request->request->get('domiciliation_address_id');
  552.             if ($domiciliationAddressId) {
  553.                 $domiciliationAddress = $entityManager->getRepository(DomiciliationAddress::class)->find($domiciliationAddressId);
  554.                 if ($domiciliationAddress && $domiciliationAddress->getClient() === $society->getClient()) {
  555.                     $society->setDomiciliationAddress($domiciliationAddress);
  556.                 }
  557.             } else {
  558.                 $society->setDomiciliationAddress(null);
  559.             }
  561.             $society->setUpdated(new \DateTime("now"));
  562.             $userSocietyAcitvities = new UserSocietyActivities();
  563.             $userSocietyAcitvities->setSociety($society);
  564.             $userSocietyAcitvities->setUser($this->getUser());
  565.             $userSocietyAcitvities->setClient($society->getClient());
  566.             $userSocietyAcitvities->setUpdatedAt(new \DateTime());
  567.             $entityManager->persist($userSocietyAcitvities);
  568.             $entityManager->flush();
  569.             $dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_REMOVE_DOCUMENTS);
  570.             $dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_CREATE);
  571.             //$dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_UPDATE);
  573.             $entityManager->flush();
  575.             return $this->redirectToRoute('society_show', ['id' => $society->getId()], Response::HTTP_SEE_OTHER);
  576.         }
  578.         $user = $this->getUser();
  579.         $client = $user->getClient();
  580.         $domiciliationAddresses = $client ? $client->getDomiciliationAddresses() : [];
  582.         $files = $filesRepository->findBy(['society' => $society->getId()]);
  583.         $publicDirectory = $this->getParameter('file_directory');
  584.         return $this->renderForm('society/edit.html.twig', [
  585.             'society' => $society,
  586.             'form' => $form,
  587.             'associes' => $society->getAssocies(),
  588.             'presidents' => $society->getPresidents(),
  589.             'files' => $files,
  590.             'directory' => "uploads/societyDocuments/",
  591.             'domiciliationAddresses' => $domiciliationAddresses,
  592.         ]);
  593.     }
  595. //    *****************************************************edit button ************************************************************************
  597.     /**
  598.      * @Route("/{id}/generate-documents", name="society_generate_documents", methods={"GET", "POST"})
  599.      */
  600.     public function generate(Request $request, Society $society, EntityManagerInterface $entityManager, EventDispatcherInterface $dispatcher): Response
  601.     {
  602.         if ($society->getDocumentSocieties()) {
  603.             foreach ($society->getDocumentSocieties() as $documentSociety) {
  604.                 if ($documentSociety->getSignatures()) {
  605.                     foreach ($documentSociety->getSignatures() as $signature) {
  606.                         $entityManager->remove($signature);
  607.                     }
  608.                 }
  609.                 $entityManager->flush();
  610.             }
  612.         }
  613.         $publicDirectory = $this->getParameter('pdf_directory');
  614.         $filepath = $publicDirectory . "/" . $society->getId() . "/";
  615.         if (!file_exists($filepath)) {
  616.             mkdir($filepath, 0777, true);
  617.         }
  618.         //hna n3adi fil path li houwa ploads/societyPdf/
  619.         $dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_REMOVE_DOCUMENTS);
  620.         $dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_CREATE);
  621.         $dispatcher->dispatch(new GenericEvent($society, [$filepath]), DocumentEvent::SOCIETY_REMOVE_DOCUMENTS_FOLDER);
  623.         $entityManager->flush();
  625.         // Rediriger après modification
  626.         return $this->redirectToRoute('society_show', ['id' => $society->getId()], Response::HTTP_SEE_OTHER);
  628.     }
  631. //    *****************************************************edit button ************************************************************************
  634.     /**
  635.      * @Route("/{id}", name="society_delete", methods={"POST"})
  636.      */
  637.     public function delete(Request $request, Society $society, EntityManagerInterface $entityManager): Response
  638.     {
  639.         if ($this->isCsrfTokenValid('delete' . $society->getId(), $request->request->get('_token'))) {
  640.             try {
  641.                 $societyName = $society->getName();
  642.                 $entityManager->remove($society);
  643.                 $entityManager->flush();
  645.                 $this->addFlash('success', 'La société "' . $societyName . '" a été supprimée avec succès.');
  646.             } catch (\Exception $e) {
  647.                 $this->addFlash('error', 'Impossible de supprimer cette société : ' . $e->getMessage());
  648.             }
  649.         }
  651.         return $this->redirectToRoute('society_index', [], Response::HTTP_SEE_OTHER);
  652.     }
  655.     /**
  656.      * @Route("/upload/{id}", name="society_upload", methods={"POST"})
  657.      */
  658.     public function uploadDocuments(Request $request, Society $society, FilesRepository $filesRepository)
  659.     {
  661.         if ($request->getMethod() == "POST") {
  662.             $entityManager = $this->getDoctrine()->getManager();
  663.             $file = $request->files->get('file');
  664.             $fileName = $file->getClientOriginalName();
  665.             $publicDirectory = $this->getParameter('file_directory');
  666.             $filepath = $publicDirectory . "/" . $society->getId();
  667.             if (!file_exists($filepath)) {
  668.                 mkdir($filepath, 0777, true);
  669.             }
  670.             $fileName = $file->getClientOriginalName();
  671.             $file->move(
  672.                 $filepath,
  673.                 $fileName
  674.             );
  676.             $fileEntity = new Files();
  677.             $fileEntity->setName($fileName);
  678.             $fileEntity->setPath($society->getId() . '/' . $fileName);
  679.             $fileEntity->setSociety($society);
  680.             $entityManager->persist($fileEntity);
  681.             $entityManager->flush();
  682.             $html = $this->renderView('society/_document_ajax.html.twig', [
  683.                 'files' => $filesRepository->findBy(['society' => $society->getId()]),
  684.                 'directory' => "uploads/societyDocuments/",
  685.                 'society' => $society
  686.             ]);
  687.             return new Response($html);
  688.         }
  689.     }
  691.     /**
  692.      * @Route("/deleteFile/{id}/{file}", name="delete_file")
  693.      */
  694.     public function refreshDocuments(Request $request, Society $society, $file, FilesRepository $filesRepository)
  695.     {
  696.         $entityManager = $this->getDoctrine()->getManager();
  697.         $fileEntity = $filesRepository->find($file);
  698.         $publicDirectory = $this->getParameter('file_directory');
  699.         $filepath = $publicDirectory . "/" . $fileEntity->getPath();
  700.         if (file_exists($filepath)) unlink($filepath);
  702.         $entityManager->remove($fileEntity);
  703.         $entityManager->flush();
  704.         $referer = $request->headers->get('referer');
  705.         return new RedirectResponse($referer);
  707.     }
  709.     /**
  710.      * @Route("/new/{id}", name="app_society_update_Clauses", methods={"GET", "POST"})
  711.      */
  712.     public function updateStatus(Request $request, Society $society, EntityManagerInterface $entityManager): Response
  713.     {
  715.         if ($request->isXmlHttpRequest()) {
  716.             $data = $request->request->all();
  718.             $result = $selectedClauses = [];
  719.             $profilName = !empty($data['profil-name']) ? $data['profil-name'] : null;
  720.             $profilId   = !empty($data['profil-id'])   ? (int)$data['profil-id']   : null;
  722.             // Keys posted by the form that are NOT clause refs — must not pollute societyStatus
  723.             $nonClauseKeys = ['profil-name', 'profil-id', 'profile', '_token', 'save-mode'];
  725.             foreach ($data as $key => $value) {
  726.                 if (in_array($key, $nonClauseKeys, true)) {
  727.                     continue;
  728.                 }
  729.                 if (strpos($key, 'condition_') === 0) {
  730.                     $result[$key] = $value;
  731.                 } else {
  732.                     $result[] = $key;
  733.                     if ($profilName || $profilId) {
  734.                         $clause = $entityManager->getRepository(ClauseScoiety::class)->findOneBy(['ref' => $key]);
  735.                         if ($clause) {
  736.                             $selectedClauses[] = $clause->getId();
  737.                         }
  738.                     }
  739.                 }
  740.             }
  742.             if ($profilName && $selectedClauses) {
  743.                 // Créer un nouveau profil
  744.                 $selection = new UserClauseSelection();
  745.                 $selection->setUser($this->getUser());
  746.                 $selection->setSocietyType($society->getType());
  747.                 $selection->setName($profilName);
  748.                 $selection->setCreatedAt(new \DateTime());
  749.                 $selection->setClauses($selectedClauses);
  750.                 $entityManager->persist($selection);
  751.                 $entityManager->flush();
  752.                 $society->setSelectedProfil($selection);
  753.                 $entityManager->flush();
  754.             } elseif ($profilId && $selectedClauses) {
  755.                 // Mettre à jour un profil existant
  756.                 $selection = $entityManager->getRepository(UserClauseSelection::class)->find($profilId);
  757.                 if ($selection) {
  758.                     $selection->setClauses($selectedClauses);
  759.                     $entityManager->flush();
  760.                     $society->setSelectedProfil($selection);
  761.                     $entityManager->flush();
  762.                 }
  763.             } else {
  764.                 // Pas d'action profil : la sélection de la société ne correspond plus à un profil sauvegardé
  765.                 $society->setSelectedProfil(null);
  766.             }
  768.             $society->setSocietyStatus($result);
  769.             $entityManager->persist($society);
  770.             $entityManager->flush();
  772.             return new Response('succes', Response::HTTP_OK);
  773.         }
  775.         return new Response('failed', Response::HTTP_BAD_REQUEST);
  776.     }
  778.     /**
  779.      * @Route("/preview-statuts/{id}", name="app_society_preview_statuts", methods={"POST"})
  780.      */
  781.     public function previewStatuts(Request $request, Society $society, EntityManagerInterface $entityManager): Response
  782.     {
  783.         if (!$request->isXmlHttpRequest()) {
  784.             return new JsonResponse(['error' => 'Invalid request'], Response::HTTP_BAD_REQUEST);
  785.         }
  787.         $data = $request->request->all();
  788.         
  789.         // Traitement des clauses similaire à updateStatus
  790.         $result = [];
  791.         foreach ($data as $key => $value) {
  792.             if (strpos($key, 'condition_') === 0) {
  793.                 $result[$key] = $value;
  794.             } else {
  795.                 $result[] = $key;
  796.             }
  797.         }
  798.         
  799.         // Récupération des clauses/statuts pour le type de société
  800.         mb_internal_encoding("UTF-8");
  801.         $societyTypeName = $society->getType()->getName();
  802.         $decodedName = mb_convert_case($societyTypeName, MB_CASE_LOWER, "UTF-8");
  803.         $includeCommon = !str_contains($decodedName, 'sasu');
  804.         $allStatuts = $entityManager->getRepository(ClauseScoiety::class)->findBySocietyType($decodedName, $includeCommon);
  805.         $checkedRefs = array_values(array_filter(array_keys($result), 'is_int'));
  806.         $checkedRefs = array_map(function($k) use ($result) { return $result[$k]; }, $checkedRefs);
  807.         $statuts = array_values(array_filter($allStatuts, function($s) use ($checkedRefs) {
  808.             return in_array($s->getRef(), $checkedRefs);
  809.         }));
  810.         
  811.         // Simulation de la mise à jour temporaire pour la preview
  812.         $conditionData = [];
  813.         foreach ($result as $key => $value) {
  814.             if (is_string($key) && strpos($key, 'condition_') === 0) {
  815.                 $conditionData[$key] = $value;
  816.             }
  817.         }
  819.         $tempSociety = clone $society;
  820.         $tempSociety->setSocietyStatus($result);
  821.         // Override DB clauseConditionsArray with live form data so preview reflects current state
  822.         $tempSociety->setClauseConditionsArray($conditionData);
  823.         
  824.         // Génération du PDF en mémoire
  825.         $pdfOptions = new \Dompdf\Options();
  826.         $pdfOptions->set('defaultFont', 'Arial');
  827.         $pdfOptions->set('isRemoteEnabled', true);
  828.         
  829.         $dompdf = new \Dompdf\Dompdf($pdfOptions);
  830.         
  831.         // Template du document statuts
  832.         $template = 'documentsPdf/statuts.html.twig';
  833.         if (!$this->container->get('twig')->getLoader()->exists($template)) {
  834.             return new JsonResponse(['error' => 'Template not found'], Response::HTTP_NOT_FOUND);
  835.         }
  836.         try {
  837.             $html = $this->container->get('twig')->render($template, [
  838.                 'society' => $tempSociety,
  839.                 'statuts' => $statuts,
  840.                 'data' => $result
  841.             ]);
  842.             
  843.             $dompdf->loadHtml($html);
  844.             $dompdf->setPaper('A4', 'portrait');
  845.             $dompdf->render();
  846.             
  847.             // Ajout du footer
  848.             $canvas = $dompdf->get_canvas();
  849.             $w = $canvas->get_width();
  850.             $h = $canvas->get_height();
  852.             // Résolution correcte du font via FontMetrics (évite arial.afm introuvable sur Linux)
  853.             $fontMetrics = $dompdf->getFontMetrics();
  854.             $footerFont = $fontMetrics->getFont('Helvetica', 'normal')
  855.                 ?? $fontMetrics->getFont('helvetica', 'normal')
  856.                 ?? $fontMetrics->getFont('Times', 'normal');
  858.             // Footer personnalisé ou par défaut
  859.             $customFooter = null;
  860.             if ($society->getClient() && $society->getClient()->getLogo()) {
  861.                 $customFooter = $society->getClient()->getLogo()->getPiedDePage();
  862.             }
  864.             if ($customFooter) {
  865.                 $canvas->page_text(30, $h - 30, $customFooter, $footerFont, 9, [0, 0, 0]);
  866.             } else {
  867.                 $canvas->page_text(30, $h - 30, $society->getName(), $footerFont, 9, [0, 0, 0]);
  868.                 $canvas->page_text($w / 2 - 60, $h - 30, "Généré le " . date('d/m/Y'), $footerFont, 9, [0, 0, 0]);
  869.             }
  871.             $canvas->page_text($w - 120, $h - 30, "Page {PAGE_NUM} de {PAGE_COUNT}", $footerFont, 9, [0, 0, 0]);
  872.             $canvas->line(30, $h - 45, $w - 30, $h - 45, [0.5, 0.5, 0.5], 0.5);
  873.             
  874.             $output = $dompdf->output();
  875.             
  876.             // Retourner le PDF en base64 pour affichage dans l'iframe
  877.             return new JsonResponse([
  878.                 'success' => true,
  879.                 'pdf' => base64_encode($output),
  880.                 'mime' => 'data:application/pdf;base64,'
  881.             ]);
  882.             
  883.         } catch (\Exception $e) {
  884.             error_log('[previewStatuts] Exception: ' . $e->getMessage() . ' in ' . $e->getFile() . ':' . $e->getLine());
  885.             return new JsonResponse(['error' => 'Erreur: ' . $e->getMessage()], Response::HTTP_INTERNAL_SERVER_ERROR);
  886.         }
  887.     }
  889.     /**
  890.      * @Route("/sendMail/{id}", name="app_society_send_document", methods={"GET", "POST"})
  891.      */
  892.     public function sendDocumentByMail(Request $request, int $id): Response
  893.     {
  894.         // Récupère le document en utilisant son ID
  895.         $documentSociety = $this->documentSocietyRepository->find($id);
  896.         if (!$documentSociety) {
  897.             throw $this->createNotFoundException('Le document n\'existe pas');
  898.         }
  900.         // Récupère la société associée au document
  901.         $society = $documentSociety->getSociety();
  903.         if ($request->isMethod('POST')) {
  904.             $recipients = $request->request->get('emails', []);
  905.             $content = $request->request->get('content', '');
  907.             // Récupère le chemin S3 du fichier PDF
  908.             $s3Key = $this->s3Service->extractKeyFromUrl($documentSociety->getPath());
  909.             // Utilise le service S3 pour récupérer le contenu du fichier
  910.             $fileContent = $this->s3Service->downloadDocument($s3Key);
  911.             if (!$fileContent) {
  912.                 throw $this->createNotFoundException('Impossible de récupérer le fichier PDF depuis AWS S3');
  913.             }
  915.             // Convertit le flux en contenu lisible
  916.             if ($fileContent instanceof \Psr\Http\Message\StreamInterface) {
  917.                 $fileContent = $fileContent->getContents();
  918.             }
  920.             // Détermine le nom du fichier
  921.             $filename = $documentSociety->getNameFormated() . '.pdf';
  923.             // Envoie un email avec le fichier PDF en pièce jointe à chaque destinataire
  924.             foreach ($recipients as $recipient) {
  925.                 $this->mailService->sendEmailWithAttachment($recipient, 'MacsSolution.fr (Nouveau document)', $content, $fileContent, $filename);
  926.             }
  928.             $this->addFlash('success', 'Le mail a été envoyé avec succès.');
  929.             return $this->redirectToRoute('society_show', ['id' => $society->getId()]);
  930.         }
  932.         return $this->redirectToRoute('society_show', ['id' => $society->getId()]);
  933.     }
  936.     /**
  937.      * @Route("/society/update-signataires-by-document", name="app_society_update_signataires_document", methods={"POST"})
  938.      */
  939.     public function updateSignataires(Request $request, EntityManagerInterface $entityManager, DocumentSocietyRepository $documentSocietyRepository): Response
  940.     {
  941.         if ($request->isXmlHttpRequest()) {
  942.             $data = $request->request->all();
  943.             $document = $documentSocietyRepository->find($data['documentId']);
  944.             $signataires = $data['selectedSignataires'];
  945.             $document->setSignataires($signataires);
  946.             $entityManager->persist($document);
  947.             $entityManager->flush();
  948.             return new Response('succes', Response::HTTP_OK);
  950.         }
  951.         return new Response('failed', Response::HTTP_BAD_REQUEST);
  952.     }
  954.     /**
  955.      * @Route("/society/sendMailMultiple/{id}", name="app_society_send_document_multiple", methods={"POST"})
  956.      */
  957.     public function sendDocumentMultipleByMail(Request $request, Society $society, EntityManagerInterface $entityManager): Response
  958.     {
  959.         $action      = $request->request->get('action');
  960.         $documentIds = $request->request->get('documents', []);
  961.         $documents   = $this->documentSocietyRepository->findBy(['id' => $documentIds]);
  963.         if (empty($documents)) {
  964.             return $this->json(['error' => 'Aucun document sélectionné.'], 400);
  965.         }
  967.         // Crée un fichier ZIP temporaire
  968.         $zipName = sys_get_temp_dir() . '/' . uniqid() . '.zip';
  969.         $zip = new \ZipArchive();
  970.         $zip->open($zipName, \ZipArchive::CREATE);
  972.         $tempFiles = [];
  973.         foreach ($documents as $documentSociety) {
  974.             $key         = $this->s3Service->extractKeyFromUrl($documentSociety->getPath());
  975.             $fileContent = $this->s3Service->downloadDocument($key);
  977.             if ($fileContent && strlen($fileContent) > 0) {
  978.                 $tempFilePath = sys_get_temp_dir() . '/' . uniqid() . '.pdf';
  979.                 file_put_contents($tempFilePath, $fileContent);
  980.                 $tempFiles[] = $tempFilePath;
  981.                 $zip->addFile($tempFilePath, ($documentSociety->getNameFormated() ?: $documentSociety->getName()) . '.pdf');
  982.             }
  984.             if ($action === 'download') {
  985.                 $documentSociety->setIsDownload(true);
  986.             } elseif ($action === 'send') {
  987.                 $documentSociety->setIsSend(true);
  988.             }
  989.             $entityManager->persist($documentSociety);
  990.         }
  992.         $zip->close();
  993.         $entityManager->flush();
  995.         // Nettoyer les fichiers temporaires PDF
  996.         foreach ($tempFiles as $tmp) {
  997.             @unlink($tmp);
  998.         }
  1000.         if ($action === 'download') {
  1001.             $response = new BinaryFileResponse($zipName);
  1002.             $response->headers->set('Content-Type', 'application/zip');
  1003.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, 'documents.zip');
  1004.             $response->deleteFileAfterSend(true);
  1005.             return $response;
  1006.         }
  1008.         if ($action === 'send') {
  1009.             // Destinataires choisis dans le modal
  1010.             $emailsParam = $request->request->get('emails', []);
  1011.             $recipients  = array_unique(array_filter((array)$emailsParam));
  1013.             if (empty($recipients)) {
  1014.                 @unlink($zipName);
  1015.                 return $this->json(['error' => 'Aucun destinataire sélectionné.'], 400);
  1016.             }
  1018.             $message = $request->request->get('message', 'Veuillez trouver en pièce jointe les documents de la société ' . $society->getName() . '.');
  1020.             try {
  1021.                 $zipContent = file_get_contents($zipName);
  1022.                 foreach ($recipients as $recipient) {
  1023.                     $this->mailService->sendEmailWithAttachment(
  1024.                         $recipient,
  1025.                         'MacsSolution.fr – Documents société ' . $society->getName(),
  1026.                         $message,
  1027.                         $zipContent,
  1028.                         'documents.zip'
  1029.                     );
  1030.                 }
  1031.                 @unlink($zipName);
  1032.                 return $this->json(['success' => true, 'recipients' => count($recipients)]);
  1033.             } catch (\Exception $e) {
  1034.                 @unlink($zipName);
  1035.                 return $this->json(['error' => 'Erreur lors de l\'envoi : ' . $e->getMessage()], 500);
  1036.             }
  1037.         }
  1039.         return $this->json(['error' => 'Action invalide.'], 400);
  1040.     }
  1042.     /**
  1043.      * @Route("/activity/reformulate", name="app_activity_reformulate")
  1044.      */
  1045.     public function reformulateActivity(Request $request): JsonResponse
  1046.     {
  1047.         $data = json_decode($request->getContent(), true);
  1048.         $text = $data['text'] ?? '';
  1050.         try {
  1051.             $response = $this->httpClient->request('POST', 'https://api.openai.com/v1/chat/completions', [
  1052.                 'headers' => [
  1053.                     'Authorization' => 'Bearer ' . ($_ENV['OPENAI_API_KEY'] ?? ''),
  1054.                     'Content-Type' => 'application/json',
  1055.                 ],
  1056.                 'json' => [
  1057.                     'model' => 'gpt-4o',
  1058.                     'messages' => [
  1059.                         ['role' => 'system', 'content' => 'Tu es un assistant juridique. Génère un objet social clair à partir de mots-clés. Réponds uniquement avec le texte de l\'objet social, sans titre, sans introduction, sans mise en forme Markdown, sans astérisques, sans gras. Le texte doit commencer directement par "La société a pour objet" ou par une liste numérotée.'],
  1060.                         ['role' => 'user', 'content' => $text],
  1061.                     ],
  1062.                     'temperature' => 0.7,
  1063.                 ]
  1064.             ]);
  1066.             $statusCode = $response->getStatusCode();
  1068.             if ($statusCode === 401) {
  1069.                 return new JsonResponse(['error' => 'Clé API OpenAI invalide ou expirée. Veuillez la renouveler.'], 200);
  1070.             }
  1072.             $result = $response->toArray();
  1073.             $reformulated = $result['choices'][0]['message']['content'] ?? '';
  1075.             return new JsonResponse(['reformulated' => $reformulated]);
  1077.         } catch (\Exception $e) {
  1078.             $message = str_contains($e->getMessage(), '401')
  1079.                 ? 'Clé API OpenAI invalide ou expirée. Veuillez la renouveler.'
  1080.                 : 'Erreur lors de la génération : ' . $e->getMessage();
  1082.             return new JsonResponse(['error' => $message], 200);
  1083.         }
  1084.     }
  1088.     /**
  1089.      * @param EntityManagerInterface $entityManager
  1090.      * @return null
  1091.      */
  1092.     public function getFlush(EntityManagerInterface $entityManager)
  1093.     {
  1094.         return $entityManager->flush();
  1095.     }
  1098. }