src/Controller/SocietyController.php line 79

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