src/Controller/EuroOffice/EuroOfficeController.php line 86

Open in your IDE?
  1. <?php
  3. namespace App\Controller\EuroOffice;
  5. use App\Entity\Section;
  6. use App\Entity\User;
  7. use App\Service\EuroOffice\CallbackHandler;
  8. use App\Service\EuroOffice\DocumentStorage;
  9. use App\Service\EuroOffice\EditorConfigBuilder;
  10. use Firebase\JWT\JWT;
  11. use Firebase\JWT\Key;
  12. use Psr\Log\LoggerInterface;
  13. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  14. use Symfony\Component\HttpFoundation\JsonResponse;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Response;
  17. use Symfony\Component\Routing\Annotation\Route;
  18. use Symfony\Contracts\HttpClient\HttpClientInterface;
  20. class EuroOfficeController extends AbstractController
  21. {
  22.     public function __construct(
  23.         private readonly EditorConfigBuilder $config,
  24.         private readonly DocumentStorage $storage,
  25.         private readonly CallbackHandler $handler,
  26.         private readonly HttpClientInterface $httpClient,
  27.         private readonly LoggerInterface $logger,
  28.         private readonly string $jwtSecret,
  29.         private readonly string $publicUrl,
  30.         private readonly ?string $docserverInternalUrl = null,
  31.     ) {}
  33.     /** Renvoie la config JSON pour DocsAPI.DocEditor (consommée par le JS workroom). */
  34.     #[Route(path: '/euroffice/config/{uuid}', name: 'euroffice_config', methods: ['GET'], options: ['expose' => true])]
  35.     public function config(Section $section, Request $request): JsonResponse
  36.     {
  37.         /** @var User $user */
  38.         $user = $this->getUser();
  39.         return new JsonResponse([
  40.             'config' => $this->config->buildForSection($section, $user, $request),
  41.             'documentServerUrl' => $this->publicUrl,
  42.         ]);
  43.     }
  45.     /** Page autonome pour test isolé Euro-Office (debug). */
  46.     #[Route(path: '/euroffice/test/{uuid}', name: 'euroffice_test', methods: ['GET'])]
  47.     public function test(Section $section, Request $request): Response
  48.     {
  49.         /** @var User $user */
  50.         $user = $this->getUser();
  51.         return $this->render('workroom/euroffice_test.html.twig', [
  52.             'config' => $this->config->buildForSection($section, $user, $request),
  53.             'documentServerUrl' => $this->publicUrl,
  54.         ]);
  55.     }
  57.     /** DocServer télécharge le DOCX ici (token court signé par Symfony). */
  58.     #[Route(path: '/euroffice/file/{uuid}', name: 'euroffice_file', methods: ['GET'])]
  59.     public function download(string $uuid, Request $request): Response
  60.     {
  61.         $token = (string) $request->query->get('t');
  62.         if ($token === '') return new Response('Missing token', 401);
  63.         try {
  64.             $payload = (array) JWT::decode($token, new Key($this->jwtSecret, 'HS256'));
  65.         } catch (\Throwable) { return new Response('Invalid token', 401); }
  66.         if (($payload['sub'] ?? null) !== 'section-'.$uuid) {
  67.             return new Response('Token mismatch', 403);
  68.         }
  70.         $section = $this->getDoctrine()->getRepository(Section::class)->findOneBy(['uuid' => $uuid]);
  71.         if (!$section) return new Response('Not found', 404);
  72.         if (($payload['key'] ?? null) !== $section->getDocxKey()) return new Response('Stale', 410);
  73.         if (!$section->getDocxPath()) return new Response('No DOCX', 404);
  75.         $bytes = $this->storage->read($section->getDocxPath());
  76.         $r = new Response($bytes);
  77.         $r->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
  78.         $r->headers->set('Content-Disposition', 'attachment; filename="'.rawurlencode($section->getName()).'.docx"');
  79.         $r->headers->set('Content-Length', (string) strlen($bytes));
  80.         $r->headers->set('Cache-Control', 'no-store');
  81.         return $r;
  82.     }
  84.     /** DocServer pousse le save ici. */
  85.     #[Route(path: '/euroffice/callback/{uuid}', name: 'euroffice_callback', methods: ['POST'])]
  86.     public function callback(Section $section, Request $request): JsonResponse
  87.     {
  88.         return new JsonResponse($this->handler->handle($section, $request));
  89.     }
  91.     /**
  92.      * Force-save synchrone : le frontend l'appelle AVANT de détruire l'iframe
  93.      * (ex: changement de section, fermeture workroom). Symfony POST le
  94.      * CommandService de DocServer avec `c=forcesave` + JWT signé. DocServer
  95.      * fire alors un callback save vers nous, qui persiste le DOCX → on est
  96.      * sûr que les modifs sont sur disque avant le switch.
  97.      *
  98.      * Sans ça : DocServer attend ~10s de "no clients connected" avant de
  99.      * fire le callback → si l'utilisateur revient avant, il charge l'ancien.
  100.      *
  101.      * Body JSON : `{ "key": "<docKey>" }` (la clé renvoyée par /euroffice/config).
  102.      */
  103.     #[Route(path: '/euroffice/forcesave/{uuid}', name: 'euroffice_forcesave', methods: ['POST'], options: ['expose' => true])]
  104.     public function forceSave(string $uuid, Request $request): JsonResponse
  105.     {
  106.         /** @var User|null $user */
  107.         $user = $this->getUser();
  108.         if (!$user) return new JsonResponse(['error' => 'unauthorized'], 401);
  110.         $section = $this->getDoctrine()->getRepository(Section::class)->findOneBy(['uuid' => $uuid]);
  111.         if (!$section) return new JsonResponse(['error' => 'not_found'], 404);
  113.         $body = json_decode((string) $request->getContent(), true) ?: [];
  114.         $key = (string) ($body['key'] ?? '');
  115.         if ($key === '') return new JsonResponse(['error' => 'missing_key'], 400);
  116.         // Validation basique : la clé contient toujours l'UUID de section en
  117.         // préfixe (cf. EditorConfigBuilder). Anti-forcesave d'une clé d'une
  118.         // autre section / random.
  119.         if (!str_starts_with($key, $section->getUuid())) {
  120.             return new JsonResponse(['error' => 'key_mismatch'], 400);
  121.         }
  123.         $internalBase = rtrim((string) ($this->docserverInternalUrl ?? 'http://documentserver'), '/');
  125.         $payload = ['c' => 'forcesave', 'key' => $key];
  126.         // CommandService DocServer JWT_ENABLED : la signature du body doit
  127.         // être passée en `Authorization: Bearer <jwt>`. JWT contient `payload`.
  128.         $jwt = JWT::encode(['payload' => $payload], $this->jwtSecret, 'HS256');
  130.         try {
  131.             $r = $this->httpClient->request('POST', $internalBase.'/coauthoring/CommandService.ashx', [
  132.                 'json' => $payload,
  133.                 'headers' => ['Authorization' => 'Bearer '.$jwt],
  134.                 'timeout' => 8,
  135.                 'max_redirects' => 0,
  136.             ]);
  137.             $code = $r->getStatusCode();
  138.             $data = json_decode($r->getContent(false), true);
  139.             // DocServer renvoie `{error: 0}` si la commande est acceptée.
  140.             // 1 = no document with key, 6 = invalid token, etc.
  141.             return new JsonResponse([
  142.                 'ok' => $code < 400 && (int) ($data['error'] ?? -1) === 0,
  143.                 'docserver' => $data,
  144.             ]);
  145.         } catch (\Throwable $e) {
  146.             $this->logger->warning('forcesave: erreur CommandService', [
  147.                 'section' => $uuid,
  148.                 'error' => $e->getMessage(),
  149.             ]);
  150.             return new JsonResponse(['ok' => false, 'error' => 'docserver_unreachable'], 502);
  151.         }
  152.     }
  153. }