src/Controller/AdminController.php line 35

Open in your IDE?
  1. <?php
  2. namespace App\Controller;
  3. /*
  4.  * To change this license header, choose License Headers in Project Properties.
  5.  * To change this template file, choose Tools | Templates
  6.  * and open the template in the editor.
  7.  */
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Symfony\Component\HttpFoundation\Session\Session;
  10. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  11. use Symfony\Component\HttpFoundation\JsonResponse;
  12. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use App\Entity\Empresa;
  16. use App\Entity\Usuario;
  17. use App\Entity\ConexionBD;
  18. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  19. use Symfony\Component\HttpFoundation\File\UploadedFile;
  20. /**
  21.  * Description of AdminController
  22.  *
  23.  * @author joseangelparra
  24.  */
  25. class AdminController extends AbstractController{
  26.     //put your code here
  27.     private $params;
  28.     public function __construct(ParameterBagInterface $params){
  29.          
  30.          $this->session = new Session();
  31.          $this->params = $params;
  32.     }
  33.     
  34.     #[Route('/', name: 'login')]
  35.     public function Login(AuthenticationUtils $authenticationUtils){
  36.          $error = $authenticationUtils->getLastAuthenticationError();
  37.         
  38.         $lastUsername = $authenticationUtils->getLastUSername();
  39.         
  40.         
  41.         return $this->render('base.html.twig',array(
  42.             'error'=>$error,
  43.             'last_username'=>$lastUsername
  44.         ));
  45.     }
  46.     
  47.     public function changePWD(UserPasswordHasherInterface $encoder, EntityManagerInterface $em){
  48.         $user = $em->getRepository(Usuario::class)->find(10);
  49.         $encoded = $encoder->hashPassword($user,'docuManager2025');
  50.         $user->setPassword($encoded);
  51.         $em->persist($user);
  52.         $flush=$em->flush();
  53.         die();
  54.     }
  55.     
  56.     public function checkUserExists(Request $request, EntityManagerInterface $em){
  57.         $email = $request->request->get("user");
  58.         
  59.         $exists = $em->getRepository(Usuario::class)->findBy(array("email"=>$email));
  60.         
  61.         if($exists){
  62.             return new JsonResponse(array("exists"=>true));
  63.         }else{
  64.             return new JsonResponse(array("exists"=>false));
  65.         }
  66.     }   
  67.     
  68.     private function azurePortForTenant(int $tenantId, int $base = 12000, int $max = 20999): int {
  69.         $port = $base + $tenantId;
  70.         if ($port > $max) {
  71.             $range = max(1, $max - $base);
  72.             $port  = $base + ($tenantId % $range);
  73.         }
  74.         return $port;
  75.     }
  77.     
  78.     #[Route('/list', name: 'list')]
  79.     public function List( EntityManagerInterface $entityManager){
  80.          if (!$this->getUser() || !is_object($this->getUser())) {         
  81.             return $this->redirectToRoute('logout');
  82.         }
  83.         $empresas = $entityManager->getRepository(Empresa::class)->findAll();
  84.          
  85.          return $this->render('listusers.html.twig',array(
  86.              'empresas' => $empresas,
  87.          ));
  88.     }
  89.     
  90.     public function addEmpresa(Request $req, EntityManagerInterface $em)
  91.     {
  92.         //dd(\shell_exec('whoami'));
  93.          if (!$this->getUser() || !is_object($this->getUser())) {         
  94.             return $this->redirectToRoute('logout');
  95.         }
  96.         if ($req->request->get("submit") != "") {
  97.             $data = $req->request->all();
  99.             // Crear nombre de base de datos y credenciales aleatorios
  100.             $dbName = 'doc_' . bin2hex(random_bytes(3));
  101.             $dbUser = 'doc_' . bin2hex(random_bytes(2));
  102.             $dbPass = bin2hex(random_bytes(8));
  103.             $dbHost = 'localhost';
  104.             $dbPort = '3306';
  106.             // Credenciales de HestiaCP desde variables de entorno
  107.             $hestiaApiUrl = $_ENV['HESTIA_API_URL'];
  108.             $hestiaApiUser = $_ENV['HESTIA_API_USER'];
  109.             $hestiaApiPass = $_ENV['HESTIA_API_PASS'];
  110.             $hestiaOwner   = $_ENV['HESTIA_OWNER'];
  111.             $accessKeyId   = $_ENV['HESTIA_ACCESS_KEY_ID'] ?? '';
  112.             $secretKey     = $_ENV['HESTIA_SECRET_KEY'] ?? '';
  114.             // Variables para el script de bash
  115.             $ocrBinary  = $_ENV['OCR_BINARY'];
  116.             $filesPath  = $_ENV['FILES_PATH'];                    
  118.             $owner = $hestiaOwner; // o el dueño del hosting
  120.             $postFields = http_build_query([
  121.                 'user' => $hestiaApiUser,
  122.                 'password' => $hestiaApiPass,
  123.                 'returncode' => 'yes',
  124.                 'cmd' => 'v-add-database',
  125.                 'arg1' => $owner,
  126.                 'arg2' => $dbName,
  127.                 'arg3' => $dbUser,
  128.                 'arg4' => $dbPass,
  129.                 'arg5' => 'mysql'
  130.             ]);
  131.             //dd($postFields);            
  132.             $headers = [
  133.                 'Authorization: Bearer ' . $accessKeyId . ':' . $secretKey
  134.             ];
  137.             $ch = curl_init();
  138.             curl_setopt($ch, CURLOPT_URL, $hestiaApiUrl);
  139.             curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  140.             curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  141.             curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
  142.             curl_setopt($ch, CURLOPT_POST, true);
  143.             curl_setopt($ch, CURLOPT_POSTFIELDS, $postFields);
  144.             curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Solo si usas certificados autofirmados
  145.             
  146.             $response = curl_exec($ch);
  147.             $error = curl_error($ch);
  148.             curl_close($ch);
  149.            
  150.             if ($error || trim($response) !== '0') {
  151.                 $this->addFlash('danger', 'Error al crear la base de datos en HestiaCP: ' . ($error ?: $response));
  152.                 return $this->redirectToRoute('app_empresa_new');
  153.             }
  154.             
  155.             //Añadir sql
  156.             $sqlFile = __DIR__ . '/../../db/db_base.sql'; // Ajusta la ruta si está en otro sitio
  158.             if (!file_exists($sqlFile)) {
  159.                 $this->addFlash('danger', 'Archivo db_base.sql no encontrado.');
  160.                 return $this->redirectToRoute('app_empresa_new');
  161.             }
  163.            
  164.             $mysqli = new \mysqli($dbHost, "{$owner}_{$dbUser}", $dbPass, "{$owner}_{$dbName}", (int)$dbPort);
  166.             if ($mysqli->connect_error) {
  167.                 $this->addFlash('danger', 'Error al conectar a la base de datos: ' . $mysqli->connect_error);
  168.                 return $this->redirectToRoute('app_empresa_new');
  169.             }
  171.             $sql = file_get_contents($sqlFile);
  173.             // Eliminar líneas con DELIMITER
  174.             $sql = preg_replace('/DELIMITER\s+\$\$/', '', $sql);
  175.             $sql = preg_replace('/DELIMITER\s+;/', '', $sql);
  177.             // Separar por ';;' si los triggers usan ese delimitador (ajusta si es $$)
  178.             $statements = explode('$$', $sql);
  180.             foreach ($statements as $stmt) {
  181.                 $stmt = trim($stmt);
  182.                 if ($stmt) {
  183.                     if (!$mysqli->multi_query($stmt)) {
  184.                         $this->addFlash('danger', 'Error ejecutando SQL: ' . $mysqli->error);
  185.                         return $this->redirectToRoute('app_empresa_new');
  186.                     }
  187.                     // Limpiar cualquier resultado intermedio
  188.                     while ($mysqli->more_results() && $mysqli->next_result()) {
  189.                         $mysqli->use_result();
  190.                     }
  191.                 }
  192.             }
  193.             
  194.             $updateSql = "UPDATE users SET email = '".$data["user"]."' WHERE id = 1";
  196.             if (!$mysqli->query($updateSql)) {
  197.                 $this->addFlash('danger', 'Error al actualizar usuario: ' . $mysqli->error);
  198.                 return $this->redirectToRoute('app_empresa_new');
  199.             }
  201.             // Guardar parámetros (activeUsers + modulos_*) en la BD del cliente
  202.             $this->saveEmpresaParametros($mysqli, $data);
  204.             // SUBIR LOGO PERSONALIZADO (SI LO HAY) ===
  205.             $customLogoFile = null;
  206.             try {
  207.                 $customLogoFile = $this->uploadEmpresaLogo($req);
  208.             } catch (\Throwable $e) {
  209.                 // Aquí decides si quieres que esto sea fatal o solo un aviso
  210.                 $this->addFlash('warning', 'El logo personalizado no se pudo subir: ' . $e->getMessage());
  211.                 // Si quieres abortar todo el proceso por fallo de logo, haz return+redirect aquí.
  212.             }
  214.             // Guardar logo en la BD del cliente
  215.             $this->saveEmpresaLogo($mysqli, $data, $customLogoFile);
  217.             // Actualizar/insertar license (capacityGb y users) en la BD del cliente
  218.             $this->upsertLicense(
  219.                 $mysqli,
  220.                 $data,
  221.                 isset($data['maxDiskQuota']) && $data['maxDiskQuota'] !== '' ? (int)$data['maxDiskQuota'] : 200,
  222.                 isset($data['maxActiveUsers']) && $data['maxActiveUsers'] !== '' ? (int)$data['maxActiveUsers'] : 3
  223.             );
  225.             // Obtener modelo seleccionado del formulario (0 si placeholder)
  226.             $modelId = isset($data['extraction_model']) && $data['extraction_model'] !== '' ? (int)$data['extraction_model'] : 0;
  228.             if ((int)($data['modulo_extraccion'] ?? 0) === 1 && $modelId > 0) {
  229.                 try {
  230.                     $this->syncExtractionModelToClientDb($mysqli, $em, $modelId);
  231.                 } catch (\Throwable $e) {
  232.                     // log opcional
  233.                 }
  234.             }
  235.            
  236.             // Crear y persistir la empresa
  237.             $emp = new Empresa();
  238.             $emp->setName($data["name"]);
  239.             $emp->setMaxDiskQuota((int)$data["maxDiskQuota"]);
  240.             
  242.             
  243.             $em->persist($emp);
  244.             $em->flush();
  245.             
  246.             $conexionBD = new ConexionBD();
  247.             $conexionBD->setDbName($owner."_".$dbName);
  248.             $conexionBD->setDbUser($owner."_".$dbUser);
  249.             $conexionBD->setDbPassword($dbPass);
  250.             $conexionBD->setDbUrl($dbHost);
  251.             $conexionBD->setDbPort($dbPort);
  252.             $em->persist($conexionBD);
  253.             $em->flush();
  254.             
  255.             
  256.             $emp->setConexionBD($conexionBD);
  257.             $em->persist($emp);
  258.             $em->flush();
  259.             
  260.             //crear usuario
  261.             $user = new \App\Entity\Usuario();
  262.             $user->setEmail($data["user"]);
  263.             $user->setEmpresa($emp);
  264.             $user->setPassword("dscsdcsno2234dwvw");
  265.             $user->setStatus(1);
  266.             $user->setIsAdmin(2);
  267.             $user->setConnection($conexionBD->getId());
  268.             
  269.             $em->persist($user);
  270.             $em->flush();
  271.             
  272.             //crear el script de bash
  273.             $company_name = $emp->getId();
  275.             // "DOCU_MAX_THREADS=" por defecto 4
  276.             // "NO" al final es para desactivar FTP
  278.             // Crear archivo .service
  279.             $serviceContent = "<<<EOT
  280.             [Unit]
  281.             Description=".$data["name"]." DocuManager OCR
  282.             Requires=mariadb.service
  283.             After=mariadb.service
  285.             [Service]
  286.             Type=simple            
  287.             ExecStart=$ocrBinary localhost/".$owner."_".$dbName." ".$owner."_".$dbUser." ".$dbPass." $filesPath/".$company_name."
  288.             Restart=always
  289.             User=root
  291.             [Install]
  292.             WantedBy=multi-user.target
  293.             EOT";
  294.            
  295.             
  296.             // Guardar contenido temporal en un archivo dentro de /tmp
  297.             $serviceName = $company_name."-documanager.service";
  298.             $tmpServicePath = "/tmp/$serviceName";
  299.             file_put_contents($tmpServicePath, $serviceContent);
  300.             \chmod($tmpServicePath, 0644);
  301.             
  302.             // Mover el archivo y habilitar el servicio desde PHP con shell_exec
  303.             $commands = [
  304.                 "sudo /bin/mv /tmp/$serviceName /etc/systemd/system/$serviceName",
  305.                 "sudo /bin/systemctl daemon-reload",
  306.                 "sudo /bin/systemctl enable $serviceName",
  307.                 "sudo /bin/systemctl start $serviceName",
  308.             ];
  309.             $errors = [];
  310.             foreach ($commands as $cmd) {
  311.                 $output = \shell_exec($cmd . " 2>&1");
  312.                 if ($output !== null) {
  313.                     // Puedes loguearlo si quieres para ver errores
  314.                     error_log("CMD OUTPUT: $cmd\n$output");
  315.                     $errors[] = "CMD OUTPUT: $cmd\n$output";
  316.                 }
  317.             }
  319.             // === Crear servicio AZURE DI por tenant ===
  320.             $azureBasePort = 12000;
  321.             $tenantId      = (int)$emp->getId();
  322.             $port          = $this->azurePortForTenant($tenantId, $azureBasePort, 20999);
  323.             $serviceName   = $tenantId . "-azuredi.service";
  324.             $workdir       = "/home/docunecta/web/platform.documanager.es/public_html/newdocu/services/azure-di";
  325.             $logsDir       = $workdir . "/logs/" . $tenantId;
  327.             // Asegura carpeta de logs
  328.             @mkdir($logsDir, 0775, true);
  330.             $serviceContent = <<<EOT
  331.             [Unit]
  332.             Description=DocuManager Azure DI (tenant {$tenantId})
  333.             After=network.target
  335.             [Service]
  336.             User=root
  337.             WorkingDirectory={$workdir}
  338.             Environment=APP_HOST=127.0.0.1
  339.             Environment=APP_PORT={$port}
  340.             Environment=LOG_DIR={$logsDir}
  341.             Environment=PYTHONUNBUFFERED=1
  342.             Environment=MAX_CONCURRENT=20
  343.             Environment="PATH=/opt/azure-di/.venv/bin:/usr/local/bin:/usr/bin"
  344.             EnvironmentFile=-{$workdir}/.env
  345.             ExecStart=/opt/azure-di/.venv/bin/python -m uvicorn app.main:app --host 127.0.0.1 --port {$port} --proxy-headers --workers 2
  346.             Restart=always
  347.             RestartSec=2
  348.             StandardOutput=journal
  349.             StandardError=journal
  351.             [Install]
  352.             WantedBy=multi-user.target
  353.             EOT;
  355.             $tmpServicePath = "/tmp/{$serviceName}";
  356.             file_put_contents($tmpServicePath, $serviceContent);
  357.             @chmod($tmpServicePath, 0644);
  359.             $cmds = [
  360.                 "sudo /bin/mv {$tmpServicePath} /etc/systemd/system/{$serviceName}",
  361.                 "sudo /bin/systemctl daemon-reload",
  362.                 "sudo /bin/systemctl enable {$serviceName}",
  363.                 "sudo /bin/systemctl start {$serviceName}",
  364.             ];
  365.             foreach ($cmds as $cmd) {
  366.                 $out = \shell_exec($cmd . " 2>&1");
  367.                 if ($out !== null) { error_log("AZURE-DI CMD: $cmd\n$out"); }
  368.             }
  369.             
  370.             if(count($errors)>0){
  371.                  $this->addFlash('success', 'Empresa y base de datos creadas correctamente: '.implode(" | ",$errors));
  372.             }
  373.             
  374.             
  375.             
  376.             $this->addFlash('success', 'Empresa y base de datos creadas correctamente.');
  377.             return $this->redirectToRoute('list');
  378.         } else {
  379.             // Lee los modelos usando la conexión principal de Doctrine
  380.             $extractionModels = [];
  381.             try {
  382.                 $conn = $em->getConnection();
  383.                 $sql = 'SELECT id, model_id FROM extraction_models ORDER BY model_id';
  384.                 $extractionModels = $conn->executeQuery($sql)->fetchAllAssociative(); // ['id' => '1', 'model_name' => '...']
  385.                 // Opcional: castear id a int
  386.                 foreach ($extractionModels as &$m) { $m['id'] = (int)$m['id']; }
  387.             } catch (\Throwable $e) {
  388.                 $extractionModels = [];
  389.             }
  391.             return $this->render('empresa/_add.html.twig', [
  392.                 'extraction_models' => $extractionModels,
  393.                 'modulos' => [
  394.                     'extraction_model' => 0,
  395.                     'limite_archivos' => 500,
  396.                 ],
  397.             ]);
  398.         }
  399.     }    
  401.     private function saveEmpresaParametros(\mysqli $mysqli, array $data): void
  402.     {
  403.         // Helpers
  404.         $getInt  = fn(array $a, string $k, int $d) => (isset($a[$k]) && $a[$k] !== '') ? (int)$a[$k] : $d;
  405.         $getFlag = fn(array $a, string $k) => (isset($a[$k]) && (int)$a[$k] === 1) ? 1 : 0;
  407.         // Keys y valores tal y como quieres guardarlos
  408.         $paramMap = [
  409.             'activeUsers'        => $getInt($data, 'maxActiveUsers', 3),
  411.             'modulo_etiquetas'   => $getFlag($data, 'modulo_etiquetas'),
  412.             'modulo_calendario'  => $getFlag($data, 'modulo_calendario'),
  413.             'modulo_calExt'      => $getFlag($data, 'modulo_calendarioExterno'),            
  414.             'modulo_estados'     => $getFlag($data, 'modulo_estados'),
  415.             'modulo_subida'      => $getFlag($data, 'modulo_subida'),
  416.             'modulo_extraccion'  => $getFlag($data, 'modulo_extraccion'),
  417.             'modulo_lineas'      => $getFlag($data, 'modulo_lineas'),
  419.             'limite_archivos'  => $getInt($data, 'limite_archivos', 500),
  421.             'extraction_model'  => $getInt($data, 'extraction_model', 0),
  422.         ];
  424.         // RECOMENDADO en tu SQL base:
  425.         // ALTER TABLE parametros ADD UNIQUE KEY uniq_nombre (nombre);
  426.         $mysqli->begin_transaction();
  427.         try {
  428.             $stmt = $mysqli->prepare("
  429.                 INSERT INTO parametros (nombre, valor)
  430.                 VALUES (?, ?)
  431.                 ON DUPLICATE KEY UPDATE valor = VALUES(valor)
  432.             ");
  433.             if (!$stmt) {
  434.                 throw new \RuntimeException('Prepare parametros: ' . $mysqli->error);
  435.             }
  437.             foreach ($paramMap as $nombre => $valor) {
  438.                 // valor es TEXT en tu esquema: bindeamos como string
  439.                 $v = (string)$valor;
  440.                 $stmt->bind_param('ss', $nombre, $v);
  441.                 if (!$stmt->execute()) {
  442.                     throw new \RuntimeException("Guardar parámetro $nombre: " . $stmt->error);
  443.                 }
  444.             }
  446.             $stmt->close();
  447.             $mysqli->commit();
  448.         } catch (\Throwable $e) {
  449.             $mysqli->rollback();
  451.             // Si NO puedes añadir UNIQUE(nombre), usa fallback DELETE+INSERT:
  452.             // $this->saveParametrosFallback($mysqli, $paramMap);
  454.             throw $e;
  455.         }
  456.     }
  458.     private function saveEmpresaLogo(\mysqli $mysqli, array $data, ?string $customLogoFile = null): void
  459.     {
  460.         $this->logLogo('empresa_logo_save.log', '--- NUEVA LLAMADA saveEmpresaLogo ---');
  461.         $this->logLogo('empresa_logo_save.log', 'customLogoFile = '.var_export($customLogoFile, true));
  462.         $this->logLogo('empresa_logo_save.log', 'data[empresa_vendor] = '.var_export($data['empresa_vendor'] ?? null, true));
  464.         // 1) Decidir qué logo vamos a guardar
  465.         $logoFile = null;
  467.         // --- PRIORIDAD: LOGO PERSONALIZADO ---
  468.         if ($customLogoFile !== null && $customLogoFile !== '') {
  469.             $logoFile = $customLogoFile;
  470.             $this->logLogo('empresa_logo_save.log', 'Usando logo personalizado: '.$logoFile);
  471.         } else {
  472.             // --- SI NO HAY PERSONALIZADO, USAMOS EL SELECT DE EMPRESA ---
  473.             if (!isset($data['empresa_vendor']) || $data['empresa_vendor'] === '') {
  474.                 $this->logLogo('empresa_logo_save.log', 'No hay empresa_vendor y no hay logo custom. No hago nada.');
  475.                 return;
  476.             }
  478.             $empresa = $data['empresa_vendor'];
  480.             $logoMap = [
  481.                 'docunecta'  => 'DocuManager_transparente.png',
  482.                 'docuindexa' => 'DocuIndexa.png',
  483.             ];
  485.             if (!isset($logoMap[$empresa])) {
  486.                 $this->logLogo('empresa_logo_save.log', "empresa_vendor $empresa no está en logoMap. No hago nada.");
  487.                 return;
  488.             }
  490.             $logoFile = $logoMap[$empresa];
  491.             $this->logLogo('empresa_logo_save.log', 'Usando logo por vendor: '.$logoFile);
  492.         }
  494.         if ($logoFile === null || $logoFile === '') {
  495.             $this->logLogo('empresa_logo_save.log', 'logoFile está vacío. No hago nada.');
  496.             return;
  497.         }
  499.         $this->logLogo('empresa_logo_save.log', 'Voy a guardar en parametros.logo: '.$logoFile);
  501.         $mysqli->begin_transaction();
  503.         try {
  504.             $stmt = $mysqli->prepare("
  505.                 INSERT INTO parametros (nombre, valor)
  506.                 VALUES ('logo', ?)
  507.                 ON DUPLICATE KEY UPDATE valor = VALUES(valor)
  508.             ");
  510.             if (!$stmt) {
  511.                 $this->logLogo('empresa_logo_save.log', 'Error prepare: '.$mysqli->error);
  512.                 throw new \RuntimeException('Prepare logo: ' . $mysqli->error);
  513.             }
  515.             $stmt->bind_param('s', $logoFile);
  517.             if (!$stmt->execute()) {
  518.                 $this->logLogo('empresa_logo_save.log', 'Error execute: '.$stmt->error);
  519.                 throw new \RuntimeException('Guardar parámetro logo: ' . $stmt->error);
  520.             }
  522.             $stmt->close();
  523.             $mysqli->commit();
  524.             $this->logLogo('empresa_logo_save.log', 'Logo guardado correctamente en BD.');
  526.         } catch (\Throwable $e) {
  527.             $mysqli->rollback();
  528.             $this->logLogo('empresa_logo_save.log', 'EXCEPCIÓN: '.$e->getMessage());
  529.             throw $e;
  530.         }
  531.     }
  533.     private function uploadEmpresaLogo(Request $req): ?string
  534.     {
  535.         $this->logLogo('empresa_logo_upload.log', '--- NUEVA LLAMADA uploadEmpresaLogo ---');
  537.         // name del checkbox en el formulario (ajústalo si usas otro)
  538.         $useCustomLogo = $req->request->get('customLogoCheck');
  539.         $this->logLogo('empresa_logo_upload.log', 'customLogoCheck = '.var_export($useCustomLogo, true));
  541.         // Si no marcaron "usar logo personalizado", no hacemos nada
  542.         if (!$useCustomLogo) {
  543.             $this->logLogo('empresa_logo_upload.log', 'No se ha marcado customLogoCheck. Salgo sin subir.');
  544.             return null;
  545.         }
  547.         /** @var UploadedFile|null $file */
  548.         $file = $req->files->get('logo_personalizado'); // name="logo_personalizado" en el input file
  549.         $this->logLogo('empresa_logo_upload.log', 'FILES[logo_personalizado] = '.print_r($file, true));
  551.         if (!$file instanceof UploadedFile || !$file->isValid()) {
  552.             $this->logLogo('empresa_logo_upload.log', 'File no es UploadedFile válido. Salgo sin subir.');
  553.             return null;
  554.         }
  556.         // VALIDACIONES BÁSICAS
  557.         $maxSize = 2 * 1024 * 1024; // 2 MB por ejemplo
  558.         if ($file->getSize() > $maxSize) {
  559.             $this->logLogo('empresa_logo_upload.log', 'Tamaño demasiado grande: '.$file->getSize());
  560.             throw new \RuntimeException('El logo personalizado es demasiado grande (máx 2MB).');
  561.         }
  563.         $mime = $file->getMimeType();
  564.         $allowedMimeTypes = ['image/png', 'image/jpeg', 'image/webp', 'image/svg+xml'];
  565.         $this->logLogo('empresa_logo_upload.log', 'MIME = '.$mime);
  567.         if (!in_array($mime, $allowedMimeTypes, true)) {
  568.             $this->logLogo('empresa_logo_upload.log', 'MIME no permitido.');
  569.             throw new \RuntimeException('Formato de logo no permitido. Usa PNG, JPG, WEBP o SVG.');
  570.         }
  572.         // Directorio destino según entorno (configurado en .env/.env.local)
  573.         $targetDir = $_ENV['APP_LOGO_DIR'] ?? null;
  574.         $this->logLogo('empresa_logo_upload.log', 'APP_LOGO_DIR = '.var_export($targetDir, true));
  576.         if (!$targetDir) {
  577.             throw new \RuntimeException('APP_LOGO_DIR no está configurado en el entorno.');
  578.         }
  579.         if (!is_dir($targetDir)) {
  580.             $this->logLogo('empresa_logo_upload.log', "El directorio no existe: $targetDir");
  581.             throw new \RuntimeException("El directorio de logos no existe: $targetDir");
  582.         }
  583.         if (!is_writable($targetDir)) {
  584.             $this->logLogo('empresa_logo_upload.log', "El directorio no es escribible: $targetDir");
  585.             throw new \RuntimeException("El directorio de logos no es escribible: $targetDir");
  586.         }
  588.         // Nombre de archivo "seguro" y único
  589.         $ext = $file->guessExtension() ?: 'png';
  590.         $fileName = 'logo_empresa_' . bin2hex(random_bytes(6)) . '.' . $ext;
  591.         $this->logLogo('empresa_logo_upload.log', "Voy a mover archivo como: $fileName");
  593.         // Mover físicamente el archivo
  594.         $file->move($targetDir, $fileName);
  595.         $this->logLogo('empresa_logo_upload.log', "Fichero movido OK a $targetDir/$fileName");
  597.         // Devolvemos SOLO el nombre, que es lo que se guardará en parametros.logo
  598.         return $fileName;
  599.     }
  601.     private function logLogo(string $fileName, string $message): void
  602.     {
  603.         // Directorio de logs de Symfony (donde está dev.log/prod.log)
  604.         $logDir = $this->getParameter('kernel.logs_dir');
  606.         $fullPath = rtrim($logDir, '/').'/'.$fileName;
  608.         $line = sprintf(
  609.             "[%s] %s\n",
  610.             date('Y-m-d H:i:s'),
  611.             $message
  612.         );
  614.         file_put_contents($fullPath, $line, FILE_APPEND);
  615.     }
  617.     private function loadEmpresaLogo(\mysqli $mysqli): ?string
  618.     {
  619.         $sql = "SELECT valor FROM parametros WHERE nombre = 'logo' LIMIT 1";
  620.         $res = $mysqli->query($sql);
  621.         if (!$res) {
  622.             return null;
  623.         }
  624.         if ($row = $res->fetch_assoc()) {
  625.             return $row['valor'] ?? null;
  626.         }
  627.         return null;
  628.     }
  630.     private function upsertLicense(\mysqli $mysqli, array $data, int $capacityGb = 200, int $activeUsers = 3): void
  631.     {
  632.         $clientName = (string)($data['name'] ?? '');
  633.         $licenseStr  = 'Documanager 1.0';
  634.         $initialDate = date('Y-m-d');
  635.         $price       = 0;
  636.         $emailSender = 'Documanager.es';
  637.         $emailFrom   = 'no-reply@documanager.es';
  638.         $emailName   = 'Documanager';
  639.         $smtpHost    = 'documanager.es';
  640.         $smtpUser    = 'no-reply@documanager.es';
  641.         $smtpPort    = 587;
  642.         $smtpPass    = 'Documanager1!';
  644.         $ins = $mysqli->prepare("
  645.             INSERT INTO license
  646.                 (client, license, initialDate, capacityGb, users, price, emailSender, emailFrom, emailName, smtpHost, smtpUser, smtpPort, smtpPass)
  647.             VALUES
  648.                 (?,      ?,       ?,          ?,          ?,     ?,     ?,           ?,         ?,         ?,        ?,        ?,        ?)
  649.         ");
  650.         if (!$ins) {
  651.             throw new \RuntimeException('Prepare INSERT license: ' . $mysqli->error);
  652.         }
  653.         $ins->bind_param(
  654.             'sssiiisssssis',
  655.             $clientName, $licenseStr, $initialDate, $capacityGb, $activeUsers, $price,
  656.             $emailSender, $emailFrom, $emailName, $smtpHost, $smtpUser, $smtpPort, $smtpPass
  657.         );
  658.         if (!$ins->execute()) {
  659.             $ins->close();
  660.             throw new \RuntimeException('Execute INSERT license: ' . $ins->error);
  661.         }
  662.         $ins->close();
  663.     }
  665.     private function syncExtractionModelToClientDb(\mysqli $clientMysqli, EntityManagerInterface $em, int $modelId): void
  666.     {
  667.         if ($modelId <= 0) {
  668.             return; // no hay selección
  669.         }
  671.         // Leer MODELO + DEFINICIONES (cabecera y líneas) de la BD principal
  672.         $conn = $em->getConnection();
  674.         // 1) Modelo
  675.         $rowModel = $conn->executeQuery(
  676.             'SELECT id, provider, model_id, endpoint, api_key, type, show_confidence_badges 
  677.             FROM extraction_models 
  678.             WHERE id = ?',
  679.             [$modelId]
  680.         )->fetchAssociative();
  682.         if (!$rowModel) {
  683.             return; // id inexistente
  684.         }
  686.         // 2) Campos de cabecera
  687.         $headers = $conn->executeQuery(
  688.             'SELECT id, model_id, field_key, label, value_type, 
  689.                     order_index, visibility, order_index_table, visibility_table
  690.             FROM definitions_header
  691.             WHERE model_id = ?',
  692.             [$modelId]
  693.         )->fetchAllAssociative();
  695.         // 3) Campos de líneas
  696.         $lines = $conn->executeQuery(
  697.             'SELECT id, model_id, field_key, label, value_type,
  698.                     order_index, visibility
  699.             FROM definitions_lines
  700.             WHERE model_id = ?',
  701.             [$modelId]
  702.         )->fetchAllAssociative();
  704.         // ----- TRANSACCIÓN EN BD DEL CLIENTE -----
  705.         $clientMysqli->begin_transaction();
  707.         try {
  708.             // ------------------------------------------------
  709.             // 1) UPSERT extraction_models (cliente)
  710.             // ------------------------------------------------
  711.             $sqlModel = 'INSERT INTO extraction_models 
  712.                             (id, provider, model_id, endpoint, api_key, type, show_confidence_badges)
  713.                         VALUES (?, ?, ?, ?, ?, ?, ?)
  714.                         ON DUPLICATE KEY UPDATE
  715.                             provider = VALUES(provider),
  716.                             model_id = VALUES(model_id),
  717.                             endpoint = VALUES(endpoint),
  718.                             api_key = VALUES(api_key),
  719.                             type = VALUES(type),
  720.                             show_confidence_badges = VALUES(show_confidence_badges)';
  722.             $stmtModel = $clientMysqli->prepare($sqlModel);
  723.             if (!$stmtModel) {
  724.                 throw new \RuntimeException('Prepare INSERT extraction_models (cliente): ' . $clientMysqli->error);
  725.             }
  727.             $id       = (int)$rowModel['id'];
  728.             $provider = (string)$rowModel['provider'];
  729.             $modelIdStr = (string)$rowModel['model_id'];
  730.             $endpoint = (string)$rowModel['endpoint'];
  731.             $apiKey   = (string)$rowModel['api_key'];
  732.             $type     = (string)$rowModel['type'];
  733.             $badges   = (int)$rowModel['show_confidence_badges'];
  735.             if (
  736.                 !$stmtModel->bind_param(
  737.                     'isssssi',
  738.                     $id,
  739.                     $provider,
  740.                     $modelIdStr,
  741.                     $endpoint,
  742.                     $apiKey,
  743.                     $type,
  744.                     $badges
  745.                 )
  746.                 || !$stmtModel->execute()
  747.             ) {
  748.                 $stmtModel->close();
  749.                 throw new \RuntimeException('Execute INSERT/UPSERT extraction_models (cliente): ' . $clientMysqli->error);
  750.             }
  751.             $stmtModel->close();
  753.             // ------------------------------------------------
  754.             // 2) Sincronizar definitions_header (cliente)
  755.             //    - Primero borramos las filas del modelo
  756.             //    - Luego insertamos las de la central
  757.             // ------------------------------------------------
  758.             $stmtDelHeaders = $clientMysqli->prepare(
  759.                 'DELETE FROM definitions_header WHERE model_id = ?'
  760.             );
  761.             if (!$stmtDelHeaders) {
  762.                 throw new \RuntimeException('Prepare DELETE definitions_header (cliente): ' . $clientMysqli->error);
  763.             }
  764.             $stmtDelHeaders->bind_param('i', $id);
  765.             if (!$stmtDelHeaders->execute()) {
  766.                 $stmtDelHeaders->close();
  767.                 throw new \RuntimeException('Execute DELETE definitions_header (cliente): ' . $clientMysqli->error);
  768.             }
  769.             $stmtDelHeaders->close();
  771.             if (!empty($headers)) {
  772.                 $stmtInsHeaders = $clientMysqli->prepare(
  773.                     'INSERT INTO definitions_header 
  774.                         (id, model_id, field_key, label, value_type, 
  775.                         order_index, visibility, order_index_table, visibility_table)
  776.                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
  777.                 );
  778.                 if (!$stmtInsHeaders) {
  779.                     throw new \RuntimeException('Prepare INSERT definitions_header (cliente): ' . $clientMysqli->error);
  780.                 }
  782.                 foreach ($headers as $h) {
  783.                     $hId        = (int)$h['id'];
  784.                     $hModelId   = (int)$h['model_id'];
  785.                     $fieldKey   = (string)$h['field_key'];
  786.                     // si quieres respetar NULL tal cual, quita el (string) y pasa directamente $h['label']
  787.                     $label      = $h['label'] !== null ? (string)$h['label'] : null;
  788.                     $valueType  = (string)$h['value_type'];
  789.                     $orderIndex = (int)$h['order_index'];
  790.                     $visibility = (int)$h['visibility'];
  791.                     $orderTable = (int)$h['order_index_table'];
  792.                     $visTable   = (int)$h['visibility_table'];
  794.                     if (
  795.                         !$stmtInsHeaders->bind_param(
  796.                             'iisssiiii',
  797.                             $hId,
  798.                             $hModelId,
  799.                             $fieldKey,
  800.                             $label,
  801.                             $valueType,
  802.                             $orderIndex,
  803.                             $visibility,
  804.                             $orderTable,
  805.                             $visTable
  806.                         )
  807.                         || !$stmtInsHeaders->execute()
  808.                     ) {
  809.                         $stmtInsHeaders->close();
  810.                         throw new \RuntimeException('Execute INSERT definitions_header (cliente): ' . $clientMysqli->error);
  811.                     }
  812.                 }
  814.                 $stmtInsHeaders->close();
  815.             }
  817.             // ------------------------------------------------
  818.             // 3) Sincronizar definitions_lines (cliente)
  819.             // ------------------------------------------------
  820.             $stmtDelLines = $clientMysqli->prepare(
  821.                 'DELETE FROM definitions_lines WHERE model_id = ?'
  822.             );
  823.             if (!$stmtDelLines) {
  824.                 throw new \RuntimeException('Prepare DELETE definitions_lines (cliente): ' . $clientMysqli->error);
  825.             }
  826.             $stmtDelLines->bind_param('i', $id);
  827.             if (!$stmtDelLines->execute()) {
  828.                 $stmtDelLines->close();
  829.                 throw new \RuntimeException('Execute DELETE definitions_lines (cliente): ' . $clientMysqli->error);
  830.             }
  831.             $stmtDelLines->close();
  833.             if (!empty($lines)) {
  834.                 $stmtInsLines = $clientMysqli->prepare(
  835.                     'INSERT INTO definitions_lines
  836.                         (id, model_id, field_key, label, value_type, 
  837.                         order_index, visibility)
  838.                     VALUES (?, ?, ?, ?, ?, ?, ?)'
  839.                 );
  840.                 if (!$stmtInsLines) {
  841.                     throw new \RuntimeException('Prepare INSERT definitions_lines (cliente): ' . $clientMysqli->error);
  842.                 }
  844.                 foreach ($lines as $l) {
  845.                     $lId        = (int)$l['id'];
  846.                     $lModelId   = (int)$l['model_id'];
  847.                     $lFieldKey  = (string)$l['field_key'];
  848.                     $lLabel     = $l['label'] !== null ? (string)$l['label'] : null;
  849.                     $lType      = (string)$l['value_type'];
  850.                     $lOrder     = (int)$l['order_index'];
  851.                     $lVis       = (int)$l['visibility'];
  853.                     if (
  854.                         !$stmtInsLines->bind_param(
  855.                             'iisssii',
  856.                             $lId,
  857.                             $lModelId,
  858.                             $lFieldKey,
  859.                             $lLabel,
  860.                             $lType,
  861.                             $lOrder,
  862.                             $lVis
  863.                         )
  864.                         || !$stmtInsLines->execute()
  865.                     ) {
  866.                         $stmtInsLines->close();
  867.                         throw new \RuntimeException('Execute INSERT definitions_lines (cliente): ' . $clientMysqli->error);
  868.                     }
  869.                 }
  871.                 $stmtInsLines->close();
  872.             }
  874.             // Si todo ha ido bien
  875.             $clientMysqli->commit();
  877.         } catch (\Throwable $e) {
  878.             $clientMysqli->rollback();
  879.             throw $e;
  880.         }
  881.     }
  882.     
  883.     public function Empresa(Request $req, EntityManagerInterface $em)
  884.     {
  885.         if (!$this->getUser() || !is_object($this->getUser())) {         
  886.             return $this->redirectToRoute('logout');
  887.         }
  889.         $id = (int)$req->get("id");
  890.         if (!$id) {
  891.             $this->addFlash('warning', 'Empresa no encontrada.');
  892.             return $this->redirectToRoute("list");
  893.         }
  895.         $empresa = $em->getRepository(Empresa::class)->find($id);
  896.         if (!$empresa) {
  897.             $this->addFlash('warning', 'Empresa no encontrada.');
  898.             return $this->redirectToRoute("list");
  899.         }
  901.         $users = $em->getRepository(Usuario::class)->findBy([
  902.             "empresa" => $empresa->getId()
  903.         ]);
  905.         // Valores por defecto por si algo falla al conectar con la BD del cliente
  906.         $activeUsers            = null;
  907.         $modulos                = [];
  908.         $empresaLogo            = null;
  909.         $extractionModelLabel   = null;
  911.         $diskUsedBytes          = null;
  912.         $diskUsedGb             = null;
  914.         try {
  915.             $cx = $empresa->getConexionBD();
  916.             if ($cx) {
  917.                 $mysqli = @new \mysqli(
  918.                     $cx->getDbUrl(),
  919.                     $cx->getDbUser(),
  920.                     $cx->getDbPassword(),
  921.                     $cx->getDbName(),
  922.                     (int)$cx->getDbPort()
  923.                 );
  925.                 if (!$mysqli->connect_error) {
  926.                     // parámetros (modulos, límites, etc.)
  927.                     [$activeUsers, $modulos] = $this->loadEmpresaParametros($mysqli);
  929.                     // logo guardado en la BD del cliente
  930.                     $empresaLogo = $this->loadEmpresaLogo($mysqli);
  932.                     $diskUsedBytes = $this->loadEmpresaDiskUsageBytes($mysqli);
  933.                     $diskUsedGb = ($diskUsedBytes !== null)
  934.                         ? round($diskUsedBytes / 1024 / 1024 / 1024, 2)
  935.                         : null;
  937.                     // Si tiene extracción y modelo seleccionado, buscamos el ID legible del modelo
  938.                     if (
  939.                         !empty($modulos['modulo_extraccion']) &&
  940.                         !empty($modulos['extraction_model'])
  941.                     ) {
  942.                         try {
  943.                             $conn = $em->getConnection();
  944.                             $row = $conn->fetchAssociative(
  945.                                 'SELECT model_id FROM extraction_models WHERE id = :id',
  946.                                 ['id' => (int)$modulos['extraction_model']]
  947.                             );
  948.                             if ($row && isset($row['model_id'])) {
  949.                                 $extractionModelLabel = $row['model_id'];
  950.                             }
  951.                         } catch (\Throwable $e) {
  952.                             // Si falla, simplemente no mostramos el texto bonito del modelo
  953.                             $extractionModelLabel = null;
  954.                         }
  955.                     }
  957.                     $mysqli->close();
  958.                 }
  959.             }
  960.         } catch (\Throwable $e) {
  961.             // Aquí podrías loguear el error si quieres, pero no rompemos la pantalla
  962.         }
  964.         return $this->render('empresa_detail.html.twig', [
  965.             'empresa'              => $empresa,
  966.             'users'                => $users,
  967.             'activeUsers'          => $activeUsers,
  968.             'modulos'              => $modulos,
  969.             'empresaLogo'          => $empresaLogo,
  970.             'extractionModelLabel' => $extractionModelLabel,
  971.             'diskUsedGb' => $diskUsedGb,
  972.         ]);
  973.     } 
  974.     
  975.     public function deleteEmpresa(Request $request, EntityManagerInterface $em){
  976.         $id = $request->get("id");
  977.         
  978.         $empresa = $em->getRepository(Empresa::class)->find($id);
  979.         
  980.         $conexion = $empresa->getConexionBD();
  981.         $usuarios = $em->getRepository(Usuario::class)->findBy(array("empresa"=>$empresa->getId()));
  982.         
  984.         $hestiaApiUrl = 'https://200.234.237.107:8083/api/';
  985.         $owner = 'docunecta'; // o el dueño del hosting
  987.         
  988.         $postFields = http_build_query([
  989.             'user' => 'admin',
  990.             'password' => 'i9iQiSmxb2EpvgLq',
  991.             'returncode' => 'yes',
  992.             'cmd' => 'v-delete-database',
  993.             'arg1' => 'admin',
  994.             'arg2' => $conexion->getDbName(),
  995.             
  996.         ]);
  997.         
  998.         $accessKeyId = 'cWYbt9ShyFQ3yVRsUE8u';
  999.         $secretKey = 'e2M_5wk2_jUAlPorF7V8zfwo3_0ihu90WoLPMKwj';
  1000.         $headers = [
  1001.             'Authorization: Bearer ' . $accessKeyId . ':' . $secretKey
  1002.         ];
  1004.         $ch = curl_init();
  1005.         curl_setopt($ch, CURLOPT_URL, $hestiaApiUrl);
  1006.         curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  1007.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  1008.         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
  1009.         curl_setopt($ch, CURLOPT_POST, true);
  1010.         curl_setopt($ch, CURLOPT_POSTFIELDS, $postFields);
  1011.         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Solo si usas certificados autofirmados
  1013.         $response = curl_exec($ch);
  1014.         $error = curl_error($ch);
  1015.         curl_close($ch);
  1017.         if (($error || trim($response) !== '0') && trim($response) !== '3') {
  1018.             $this->addFlash('danger', 'Error al eliminar la base de datos en HestiaCP: ' . ($error ?: $response));
  1019.             return $this->redirectToRoute('list');
  1020.         }
  1022.         // Eliminar el servicio systemd asociado a la empresa
  1023.         $company_name = $empresa->getId();
  1025.         $serviceName = $company_name . "-documanager.service";
  1026.         $servicePath = "/etc/systemd/system/$serviceName";
  1027.         $cmds = [
  1028.             "sudo /bin/systemctl stop $serviceName",
  1029.             "sudo /bin/systemctl disable $serviceName",
  1030.             "sudo /bin/rm $servicePath",
  1031.             "sudo /bin/systemctl daemon-reload"
  1032.         ];
  1033.         $serviceErrors = [];
  1034.         foreach ($cmds as $cmd) {
  1035.             $output = @\shell_exec($cmd . " 2>&1");
  1036.             if ($output !== null && trim($output) !== '') {
  1037.                 $serviceErrors[] = "CMD OUTPUT: $cmd\n$output";
  1038.             }
  1039.         }
  1041.         $azureService = $company_name . "-azuredi.service";
  1042.         $servicePathAzure = "/etc/systemd/system/$azureService";
  1043.         $cmdsAzure = [
  1044.             "sudo /bin/systemctl stop $azureService",
  1045.             "sudo /bin/systemctl disable $azureService",
  1046.             "sudo /bin/rm $servicePathAzure",
  1047.             "sudo /bin/systemctl daemon-reload",
  1048.         ];
  1049.         foreach ($cmdsAzure as $cmd) {
  1050.             $output = @\shell_exec($cmd . " 2>&1");
  1051.             if ($output) {
  1052.                 $serviceErrors[] = "CMD OUTPUT: $cmd\n$output";
  1053.             }
  1054.         }
  1055.         
  1056.         //eliminamos usuarios
  1057.         foreach($usuarios as $user){
  1058.             $em->remove($user);
  1059.             $em->flush();
  1060.         }
  1061.         
  1062.         //eliminamos conexión
  1063.         $em->remove($conexion);
  1064.         $em->flush();
  1065.         
  1066.         //eliminamos empresa
  1067.         $em->remove($empresa);
  1068.         $em->flush();
  1069.         $msg = 'Empresa y base de datos eliminadas correctamente.';
  1070.         if (count($serviceErrors) > 0) {
  1071.             $msg .= ' ' . implode('<br>', $serviceErrors);
  1072.         }
  1073.         $this->addFlash('success', $msg);
  1074.         return $this->redirectToRoute('list');
  1075.         
  1076.     }
  1078.     public function editEmpresa(Request $request, EntityManagerInterface $em)
  1079.     {
  1080.         $id = (int)$request->get('id');
  1081.         $empresa = $em->getRepository(Empresa::class)->find($id);
  1082.         if (!$empresa) {
  1083.             throw $this->createNotFoundException('Empresa no encontrada');
  1084.         }
  1086.         // 1) Conectar a la BD del cliente con las credenciales de la central
  1087.         $cx = $empresa->getConexionBD();
  1088.         $mysqli = @new \mysqli(
  1089.             $cx->getDbUrl(),
  1090.             $cx->getDbUser(),
  1091.             $cx->getDbPassword(),
  1092.             $cx->getDbName(),
  1093.             (int)$cx->getDbPort()
  1094.         );
  1095.         if ($mysqli->connect_error) {
  1096.             $this->addFlash('danger', 'No se puede conectar a la BD del cliente: ' . $mysqli->connect_error);
  1097.             return $this->redirectToRoute('list');
  1098.         }
  1100.         if ($request->isMethod('POST') && $request->request->get('submit') !== null) {
  1101.             $data = $request->request->all();
  1103.             // 2) Actualizar SOLO central
  1104.             $empresa->setName((string)($data['name'] ?? $empresa->getName()));
  1105.             $empresa->setMaxDiskQuota(
  1106.                 isset($data['maxDiskQuota']) && $data['maxDiskQuota'] !== ''
  1107.                     ? (int)$data['maxDiskQuota']
  1108.                     : $empresa->getMaxDiskQuota()
  1109.             );
  1110.             $em->persist($empresa);
  1112.             // ---- Normalización de POST (checkboxes / select) ----
  1113.             $toBool = fn($v) => in_array(strtolower((string)$v), ['1','on','true','yes'], true);
  1115.             $extractionModel = 0;
  1116.             if (isset($data['extraction_model']) && $data['extraction_model'] !== '') {
  1117.                 $extractionModel = (int)$data['extraction_model'];
  1118.             }
  1119.             $data['extraction_model'] = $extractionModel;
  1121.             $data['modulo_extraccion']       = isset($data['modulo_extraccion'])       && $toBool($data['modulo_extraccion'])       ? 1 : 0;
  1122.             $data['modulo_etiquetas']        = isset($data['modulo_etiquetas'])        && $toBool($data['modulo_etiquetas'])        ? 1 : 0;
  1123.             $data['modulo_calendario']       = isset($data['modulo_calendario'])       && $toBool($data['modulo_calendario'])       ? 1 : 0;
  1124.             $data['modulo_calendarioExterno']= isset($data['modulo_calendarioExterno'])&& $toBool($data['modulo_calendarioExterno'])? 1 : 0;
  1125.             $data['modulo_estados']          = isset($data['modulo_estados'])          && $toBool($data['modulo_estados'])          ? 1 : 0;
  1126.             $data['modulo_lineas']           = isset($data['modulo_lineas'])           && $toBool($data['modulo_lineas'])           ? 1 : 0;
  1128.             // Dependencias
  1129.             if (!$data['modulo_calendario']) {
  1130.                 $data['modulo_calendarioExterno'] = 0;
  1131.             }
  1132.             if (!$data['modulo_extraccion']) {
  1133.                 $data['modulo_lineas']   = 0;
  1134.                 $data['extraction_model'] = 0;
  1135.             }
  1137.             // 3) Guardar en BD del cliente: parametros + license
  1138.             $this->updateEmpresaParametros($mysqli, $data);
  1140.             // 3.1) Si extracción activa y hay modelo, sincroniza modelo a BD del cliente
  1141.             if ($data['modulo_extraccion'] === 1 && $data['extraction_model'] > 0) {
  1142.                 try {
  1143.                     $this->syncExtractionModelToClientDb($mysqli, $em, (int)$data['extraction_model']);
  1144.                 } catch (\Throwable $e) {
  1145.                     // log opcional
  1146.                 }
  1147.             }
  1149.             // si prefieres solo UPDATE en license, usa una función updateLicense(); si no, upsert/insert:
  1150.             $this->updateLicense(
  1151.                 $mysqli,
  1152.                 $data,
  1153.                 $empresa->getName()
  1154.             );
  1156.             $em->flush();
  1157.             $mysqli->close();
  1159.             // Mensaje de éxito
  1160.             $this->addFlash('success', 'Empresa editada correctamente.');
  1162.             return $this->redirectToRoute('app_empresa_show', ['id' => $id]);
  1163.         }
  1165.         // 4) GET: precargar desde BD del cliente
  1166.         [$activeUsers, $modulos] = $this->loadEmpresaParametros($mysqli);
  1167.         $license = $this->loadLicense($mysqli, $empresa->getName()); // por si quieres mostrarlo
  1169.         $extractionModels = [];
  1170.         try {
  1171.             $conn = $em->getConnection(); // principal
  1172.             $sql = 'SELECT id, model_id FROM extraction_models ORDER BY model_id';
  1173.             $extractionModels = $conn->executeQuery($sql)->fetchAllAssociative();
  1174.             foreach ($extractionModels as &$m) { $m['id'] = (int)$m['id']; }
  1175.         } catch (\Throwable $e) {
  1176.             $extractionModels = [];
  1177.         }
  1179.         $mysqli->close();
  1181.         return $this->render('empresa/_edit.html.twig', [
  1182.             'empresa'      => $empresa,   // central: name + maxDiskQuota
  1183.             'id'           => $id,
  1184.             'activeUsers'  => $activeUsers, // cliente
  1185.             'modulos'      => $modulos,     // cliente
  1186.             'license'      => $license,     // opcional
  1187.             'extraction_models' => $extractionModels,
  1188.         ]);
  1189.     }
  1191.     private function loadEmpresaParametros(\mysqli $mysqli): array
  1192.     {
  1193.         // claves que nos interesan en la tabla parametros
  1194.         $keys = [
  1195.             'activeUsers',
  1196.             'modulo_etiquetas','modulo_calendario','modulo_calExt',
  1197.             'modulo_estados', 'modulo_subida', 'modulo_extraccion','modulo_lineas','limite_archivos','extraction_model',
  1198.         ];
  1199.         $placeholders = implode(',', array_fill(0, count($keys), '?'));
  1201.         $sql = "SELECT nombre, valor FROM parametros WHERE nombre IN ($placeholders)";
  1202.         $stmt = $mysqli->prepare($sql);
  1203.         if (!$stmt) {
  1204.             throw new \RuntimeException('Prepare SELECT parametros: ' . $mysqli->error);
  1205.         }
  1207.         // bind dinámico
  1208.         $types = str_repeat('s', count($keys));
  1209.         $stmt->bind_param($types, ...$keys);
  1210.         if (!$stmt->execute()) {
  1211.             $stmt->close();
  1212.             throw new \RuntimeException('Execute SELECT parametros: ' . $stmt->error);
  1213.         }
  1215.         $res = $stmt->get_result();
  1216.         $map = [];
  1217.         while ($row = $res->fetch_assoc()) {
  1218.             $map[$row['nombre']] = $row['valor'];
  1219.         }
  1220.         $stmt->close();
  1222.         // defaults seguros
  1223.         $activeUsers = isset($map['activeUsers']) ? (int)$map['activeUsers'] : 3;
  1225.         $flags = [
  1226.             'modulo_etiquetas'  => isset($map['modulo_etiquetas'])  ? (int)$map['modulo_etiquetas']  : 0,
  1227.             'modulo_calendario' => isset($map['modulo_calendario']) ? (int)$map['modulo_calendario'] : 0,
  1228.             'modulo_calExt'     => isset($map['modulo_calExt'])     ? (int)$map['modulo_calExt']     : 0,            
  1229.             'modulo_estados'    => isset($map['modulo_estados'])    ? (int)$map['modulo_estados']    : 0,
  1230.             'modulo_subida'     => isset($map['modulo_subida'])     ? (int)$map['modulo_subida']     : 0,
  1231.             'modulo_extraccion' => isset($map['modulo_extraccion']) ? (int)$map['modulo_extraccion'] : 0,
  1232.             'modulo_lineas'     => isset($map['modulo_lineas'])     ? (int)$map['modulo_lineas']     : 0,
  1233.         ];
  1235.         $limiteArchivos = isset($map['limite_archivos']) && $map['limite_archivos'] !== ''
  1236.             ? (int)$map['limite_archivos']
  1237.             : 500;
  1238.             
  1239.         // Lo añadimos a $flags para no cambiar la firma del return
  1240.         $flags['limite_archivos'] = $limiteArchivos;
  1242.         // extraction_model: default 0 (sin modelo)
  1243.         $flags['extraction_model'] = isset($map['extraction_model']) && $map['extraction_model'] !== '' ? (int)$map['extraction_model'] : 0;
  1245.         return [$activeUsers, $flags];
  1246.     }
  1248.     private function updateEmpresaParametros(\mysqli $mysqli, array $data): void
  1249.     {
  1250.         $toBool = fn($v) => in_array(strtolower((string)$v), ['1','on','true','yes'], true);
  1251.         $getInt  = fn(array $a, string $k, int $d) => (isset($a[$k]) && $a[$k] !== '') ? (int)$a[$k] : $d;
  1252.         $getFlag = fn(array $a, string $k) => (isset($a[$k]) && (int)$a[$k] === 1) ? 1 : 0;
  1254.         $paramMap = [
  1255.             'activeUsers'        => $getInt($data, 'maxActiveUsers', 3),
  1256.             'modulo_etiquetas'   => $getFlag($data, 'modulo_etiquetas'),
  1257.             'modulo_calendario'  => $getFlag($data, 'modulo_calendario'),
  1258.             'modulo_calExt'      => $getFlag($data, 'modulo_calendarioExterno'),            
  1259.             'modulo_estados'     => $getFlag($data, 'modulo_estados'),
  1260.             'modulo_subida'      => $getFlag($data, 'modulo_subida'),
  1261.             'modulo_extraccion'  => $getFlag($data, 'modulo_extraccion'),
  1262.             'modulo_lineas'      => $getFlag($data, 'modulo_lineas'),
  1263.             'limite_archivos'    => $getInt($data, 'limite_archivos', 500),
  1264.             'extraction_model'   => $getInt($data, 'extraction_model', 0),
  1265.         ];
  1267.         if ($paramMap['modulo_extraccion'] === 0) {
  1268.             $paramMap['modulo_lineas'] = 0;
  1269.             $paramMap['extraction_model'] = 0;
  1270.         }
  1271.         if ($paramMap['modulo_calendario'] === 0) {
  1272.             $paramMap['modulo_calExt'] = 0;
  1273.         }
  1274.         
  1275.         $mysqli->begin_transaction();
  1276.         try {
  1277.             $stmt = $mysqli->prepare("
  1278.                 INSERT INTO parametros (nombre, valor)
  1279.                 VALUES (?, ?)
  1280.                 ON DUPLICATE KEY UPDATE valor = VALUES(valor)
  1281.             ");
  1282.             if (!$stmt) {
  1283.                 throw new \RuntimeException('Prepare UPSERT parametros: ' . $mysqli->error);
  1284.             }
  1286.             foreach ($paramMap as $nombre => $valor) {
  1287.                 $v = (string)$valor;
  1288.                 if (!$stmt->bind_param('ss', $nombre, $v) || !$stmt->execute()) {
  1289.                     $stmt->close();
  1290.                     throw new \RuntimeException("Guardar parámetro {$nombre}: {$stmt->error}");
  1291.                 }
  1292.             }
  1294.             $stmt->close();
  1295.             $mysqli->commit();
  1296.         } catch (\Throwable $e) {
  1297.             $mysqli->rollback();
  1298.             throw $e;
  1299.         }
  1300.     }
  1302.     private function loadLicense(\mysqli $mysqli): array
  1303.     {
  1304.         // Carga opcional para mostrar en la edición: capacityGb/users (u otros)
  1305.         $sql = "SELECT client, capacityGb, users FROM license LIMIT 1";
  1306.         $res = $mysqli->query($sql);
  1307.         if ($res && $row = $res->fetch_assoc()) {
  1308.             return $row;
  1309.         }
  1310.         return [];
  1311.     }
  1313.     private function updateLicense(\mysqli $mysqli, array $data, string $clientName): void
  1314.     {
  1315.         $capacityGb  = isset($data['maxDiskQuota']) ? (int)$data['maxDiskQuota'] : 200;
  1316.         $activeUsers = isset($data['maxActiveUsers']) ? (int)$data['maxActiveUsers'] : 3;
  1318.         $stmt = $mysqli->prepare("UPDATE license SET capacityGb = ?, users = ? WHERE client = ?");
  1319.         if (!$stmt) {
  1320.             throw new \RuntimeException('Prepare UPDATE license: ' . $mysqli->error);
  1321.         }
  1323.         $stmt->bind_param('iis', $capacityGb, $activeUsers, $clientName);
  1324.         $stmt->execute();
  1325.         $stmt->close();
  1326.     }
  1327.     
  1328.     public function usersListEmpresa(Request $request,EntityManagerInterface $em){
  1329.         $id = $request->get("id");
  1330.         $users_empresa = $em->getRepository(Usuario::class)->findBy(array("empresa"=>$id));
  1331.         
  1332.          return $this->render('empresa/usersList.html.twig',array(
  1333.              'users' => $users_empresa,
  1334.              'id'=>$id
  1335.          ));
  1336.     }
  1338.     private function loadEmpresaDiskUsageBytes(\mysqli $mysqli): ?int
  1339.     {
  1340.         // Si la tabla no existe o hay error, devolvemos null para no romper la vista
  1341.         $sql = "SELECT COALESCE(SUM(size_bytes), 0) AS total_bytes FROM files";
  1342.         $res = $mysqli->query($sql);
  1344.         if (!$res) {
  1345.             return null;
  1346.         }
  1348.         $row = $res->fetch_assoc();
  1349.         $res->free();
  1351.         return isset($row['total_bytes']) ? (int)$row['total_bytes'] : 0;
  1352.     }
  1354. }