src/Service/BookCoverService.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use Symfony\Contracts\HttpClient\HttpClientInterface;
  7. class BookCoverService
  8. {
  9. private ?HttpClientInterface $httpClient;
  11. public function __construct(HttpClientInterface $httpClient = null)
  12. {
  13. $this->httpClient = $httpClient;
  14. }
  16. /**
  17. * Nettoie l'ISBN en retirant les tirets et espaces
  18. */
  19. private function cleanIsbn(?string $isbn): ?string
  20. {
  21. if (empty($isbn)) {
  22. return null;
  23. }
  24. return preg_replace('/[^0-9X]/i', '', $isbn);
  25. }
  27. /**
  28. * Effectue une requête HTTP GET
  29. */
  30. private function httpGet(string $url): ?string
  31. {
  32. try {
  33. if ($this->httpClient === null) {
  34. $context = stream_context_create([
  35. 'http' => [
  36. 'timeout' => 10,
  37. 'follow_location' => true,
  38. ]
  39. ]);
  40. $response = @file_get_contents($url, false, $context);
  41. return $response !== false ? $response : null;
  42. } else {
  43. $response = $this->httpClient->request('GET', $url, [
  44. 'timeout' => 10,
  45. ]);
  46. return $response->getStatusCode() === 200 ? $response->getContent() : null;
  47. }
  48. } catch (\Exception $e) {
  49. return null;
  50. }
  51. }
  53. /**
  54. * Recherche une couverture via Google Books API
  55. */
  56. public function getCoverUrlFromGoogleBooks(?string $isbn): ?string
  57. {
  58. $isbn = $this->cleanIsbn($isbn);
  59. if (empty($isbn)) {
  60. return null;
  61. }
  63. $url = "https://www.googleapis.com/books/v1/volumes?q=isbn:{$isbn}";
  64. $response = $this->httpGet($url);
  66. if ($response) {
  67. $data = json_decode($response, true);
  68. if (isset($data['items'][0]['volumeInfo']['imageLinks']['thumbnail'])) {
  69. $imageUrl = $data['items'][0]['volumeInfo']['imageLinks']['thumbnail'];
  70. // Améliorer la qualité de l'image
  71. $imageUrl = str_replace('zoom=1', 'zoom=0', $imageUrl);
  72. $imageUrl = str_replace('&edge=curl', '', $imageUrl);
  73. $imageUrl = str_replace('http://', 'https://', $imageUrl);
  74. return $imageUrl;
  75. }
  76. }
  78. return null;
  79. }
  81. /**
  82. * Génère l'URL Open Library pour une couverture
  83. */
  84. public function getOpenLibraryCoverUrl(?string $isbn, string $size = 'L'): ?string
  85. {
  86. $isbn = $this->cleanIsbn($isbn);
  87. if (empty($isbn)) {
  88. return null;
  89. }
  90. return "https://covers.openlibrary.org/b/isbn/{$isbn}-{$size}.jpg";
  91. }
  93. /**
  94. * Vérifie si Open Library a une couverture pour cet ISBN
  95. */
  96. public function checkOpenLibraryCover(?string $isbn): bool
  97. {
  98. $isbn = $this->cleanIsbn($isbn);
  99. if (empty($isbn)) {
  100. return false;
  101. }
  103. $url = "https://openlibrary.org/api/books?bibkeys=ISBN:{$isbn}&format=json&jscmd=data";
  104. $response = $this->httpGet($url);
  106. if ($response) {
  107. $data = json_decode($response, true);
  108. if (!empty($data) && isset($data["ISBN:{$isbn}"])) {
  109. // Vérifier si une couverture existe
  110. return isset($data["ISBN:{$isbn}"]['cover']);
  111. }
  112. }
  114. return false;
  115. }
  117. /**
  118. * Recherche la meilleure image disponible en essayant plusieurs sources
  119. *
  120. * @param string|null $isbn ISBN du livre
  121. * @return array{url: string|null, source: string|null}
  122. */
  123. public function findBestCover(?string $isbn): array
  124. {
  125. $isbn = $this->cleanIsbn($isbn);
  126. if (empty($isbn)) {
  127. return ['url' => null, 'source' => null];
  128. }
  130. // 1. Essayer Google Books (meilleure qualité généralement)
  131. $url = $this->getCoverUrlFromGoogleBooks($isbn);
  132. if ($url) {
  133. return ['url' => $url, 'source' => 'Google Books'];
  134. }
  136. // 2. Essayer Open Library avec vérification
  137. if ($this->checkOpenLibraryCover($isbn)) {
  138. $url = $this->getOpenLibraryCoverUrl($isbn, 'L');
  139. if ($url && $this->isValidImage($url)) {
  140. return ['url' => $url, 'source' => 'Open Library'];
  141. }
  142. }
  144. // 3. Essayer Amazon page produit directe (meilleure qualité)
  145. $url = $this->scrapeAmazonProductPage($isbn);
  146. if ($url && $this->isValidImageUrl($url)) {
  147. return ['url' => $url, 'source' => 'Amazon (produit)'];
  148. }
  150. // 4. Essayer Amazon recherche
  151. $url = $this->scrapeAmazonFr($isbn);
  152. if ($url && $this->isValidImageUrl($url)) {
  153. return ['url' => $url, 'source' => 'Amazon (recherche)'];
  154. }
  156. // 5. Générer URL directe vers image Open Library (sans vérification)
  157. // Open Library redirige vers l'image si elle existe
  158. $url = $this->getOpenLibraryCoverUrl($isbn, 'L');
  159. if ($url) {
  160. return ['url' => $url, 'source' => 'Open Library (direct)'];
  161. }
  163. return ['url' => null, 'source' => null];
  164. }
  166. /**
  167. * Scrape Amazon.fr pour trouver l'image de couverture
  168. */
  169. public function scrapeAmazonFr(?string $isbn): ?string
  170. {
  171. $isbn = $this->cleanIsbn($isbn);
  172. if (empty($isbn)) {
  173. return null;
  174. }
  176. try {
  177. // Rechercher sur Amazon.fr
  178. $searchUrl = "https://www.amazon.fr/s?k={$isbn}";
  180. $context = stream_context_create([
  181. 'http' => [
  182. 'timeout' => 15,
  183. 'follow_location' => true,
  184. 'max_redirects' => 3,
  185. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\r\n" .
  186. "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n" .
  187. "Accept-Language: fr-FR,fr;q=0.9,en;q=0.8\r\n" .
  188. "Accept-Encoding: gzip, deflate\r\n" .
  189. "Connection: keep-alive\r\n" .
  190. "Upgrade-Insecure-Requests: 1\r\n"
  191. ]
  192. ]);
  194. $html = @file_get_contents($searchUrl, false, $context);
  196. if ($html) {
  197. // Patterns multiples pour capturer les images Amazon
  198. $patterns = [
  199. // Pattern 1: data-image-latency
  200. '/data-image-latency="s-product-image"[^>]*src="([^"]+)"/',
  201. // Pattern 2: class s-image
  202. '/<img[^>]+class="[^"]*s-image[^"]*"[^>]+src="([^"]+)"/',
  203. // Pattern 3: srcset avec la plus grande image
  204. '/srcset="([^"]+)"\s+class="[^"]*s-image/',
  205. // Pattern 4: data-old-hires
  206. '/data-old-hires="([^"]+)"/',
  207. // Pattern 5: image dans le JSON embarqué
  208. '/"hiRes":"([^"]+)"/',
  209. ];
  211. foreach ($patterns as $pattern) {
  212. if (preg_match($pattern, $html, $matches)) {
  213. $imageUrl = $matches[1];
  215. // Si c'est un srcset, prendre la première URL
  216. if (strpos($imageUrl, ',') !== false) {
  217. $parts = explode(',', $imageUrl);
  218. $imageUrl = trim(explode(' ', $parts[0])[0]);
  219. }
  221. // Nettoyer l'URL et améliorer la qualité
  222. $imageUrl = html_entity_decode($imageUrl);
  223. // Remplacer les dimensions pour avoir la meilleure qualité
  224. $imageUrl = preg_replace('/\._[A-Z]+[0-9]+_\./', '.', $imageUrl);
  225. $imageUrl = preg_replace('/\._[A-Z]{2}[0-9]+,?[0-9]*_\./', '.', $imageUrl);
  227. // Vérifier que c'est une vraie URL d'image
  228. if ($this->isValidImageUrl($imageUrl)) {
  229. return $imageUrl;
  230. }
  231. }
  232. }
  233. }
  234. } catch (\Exception $e) {
  235. // Silently fail
  236. }
  238. return null;
  239. }
  241. /**
  242. * Scrape la page produit Amazon.fr directement avec l'ISBN
  243. */
  244. public function scrapeAmazonProductPage(?string $isbn): ?string
  245. {
  246. $isbn = $this->cleanIsbn($isbn);
  247. if (empty($isbn)) {
  248. return null;
  249. }
  251. try {
  252. // Accéder directement à la page produit via ISBN
  253. $productUrl = "https://www.amazon.fr/dp/{$isbn}";
  255. $context = stream_context_create([
  256. 'http' => [
  257. 'timeout' => 15,
  258. 'follow_location' => true,
  259. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\r\n" .
  260. "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n" .
  261. "Accept-Language: fr-FR,fr;q=0.9,en;q=0.8\r\n"
  262. ]
  263. ]);
  265. $html = @file_get_contents($productUrl, false, $context);
  267. if ($html) {
  268. // Chercher l'image principale du produit
  269. if (preg_match('/"hiRes":"([^"]+)"/', $html, $matches)) {
  270. return str_replace('\\/', '/', $matches[1]);
  271. }
  273. if (preg_match('/"large":"([^"]+)"/', $html, $matches)) {
  274. return str_replace('\\/', '/', $matches[1]);
  275. }
  277. // Image dans le tag img principal
  278. if (preg_match('/<img[^>]+id="landingImage"[^>]+src="([^"]+)"/', $html, $matches)) {
  279. $imageUrl = $matches[1];
  280. $imageUrl = preg_replace('/\._[A-Z]+[0-9]+_\./', '.', $imageUrl);
  281. return $imageUrl;
  282. }
  283. }
  284. } catch (\Exception $e) {
  285. // Silently fail
  286. }
  288. return null;
  289. }
  291. /**
  292. * Vérifie si une URL pointe vers une vraie image (pas un placeholder)
  293. */
  294. private function isValidImage(string $url): bool
  295. {
  296. $content = $this->httpGet($url);
  298. if ($content === null) {
  299. return false;
  300. }
  302. // Vérifier la taille - une vraie couverture fait généralement plus de 5KB
  303. if (strlen($content) < 5000) {
  304. return false;
  305. }
  307. return true;
  308. }
  310. /**
  311. * Télécharge l'image et retourne son contenu binaire
  312. */
  313. public function downloadImage(string $url): ?string
  314. {
  315. $content = $this->httpGet($url);
  317. // Vérifier que c'est une vraie image (pas un placeholder)
  318. if ($content !== null && strlen($content) > 1000) {
  319. return $content;
  320. }
  322. return null;
  323. }
  325. /**
  326. * Scrape une page web et récupère toutes les images de produit
  327. *
  328. * @param string|null $pageUrl URL de la page à scraper
  329. * @return array Liste des URLs d'images trouvées
  330. */
  331. public function scrapeImagesFromUrl(?string $pageUrl): array
  332. {
  333. if (empty($pageUrl)) {
  334. return [];
  335. }
  337. $images = [];
  339. try {
  340. $context = stream_context_create([
  341. 'http' => [
  342. 'timeout' => 15,
  343. 'follow_location' => true,
  344. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\r\n" .
  345. "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n" .
  346. "Accept-Language: fr-FR,fr;q=0.9,en;q=0.8\r\n"
  347. ],
  348. 'ssl' => [
  349. 'verify_peer' => false,
  350. 'verify_peer_name' => false,
  351. ]
  352. ]);
  354. $html = @file_get_contents($pageUrl, false, $context);
  356. if (!$html) {
  357. return [];
  358. }
  360. // Détecter le type de site et adapter le scraping
  361. if (strpos($pageUrl, 'amazon') !== false) {
  362. $images = $this->extractAmazonImages($html);
  363. } elseif (strpos($pageUrl, 'fnac') !== false) {
  364. $images = $this->extractFnacImages($html);
  365. } elseif (strpos($pageUrl, 'babelio') !== false) {
  366. $images = $this->extractBabelioImages($html);
  367. } else {
  368. // Extraction générique
  369. $images = $this->extractGenericImages($html, $pageUrl);
  370. }
  372. } catch (\Exception $e) {
  373. // Silently fail
  374. }
  376. // Filtrer les doublons et les images trop petites
  377. return array_values(array_unique($images));
  378. }
  380. /**
  381. * Extrait les images depuis une page Amazon
  382. */
  383. private function extractAmazonImages(string $html): array
  384. {
  385. $images = [];
  387. // Images haute résolution dans le JSON
  388. if (preg_match_all('/"hiRes"\s*:\s*"([^"]+)"/', $html, $matches)) {
  389. foreach ($matches[1] as $url) {
  390. $url = str_replace('\\/', '/', $url);
  391. if ($this->isProductImage($url)) {
  392. $images[] = $url;
  393. }
  394. }
  395. }
  397. // Images "large" dans le JSON
  398. if (preg_match_all('/"large"\s*:\s*"([^"]+)"/', $html, $matches)) {
  399. foreach ($matches[1] as $url) {
  400. $url = str_replace('\\/', '/', $url);
  401. if ($this->isProductImage($url)) {
  402. $images[] = $url;
  403. }
  404. }
  405. }
  407. // Image principale (landingImage)
  408. if (preg_match('/<img[^>]+id="landingImage"[^>]+(?:src|data-old-hires)="([^"]+)"/', $html, $matches)) {
  409. $url = $matches[1];
  410. // Améliorer la qualité
  411. $url = preg_replace('/\._[A-Z]{2}[0-9]+_\./', '.', $url);
  412. if ($this->isProductImage($url)) {
  413. $images[] = $url;
  414. }
  415. }
  417. // Images dans data-a-dynamic-image
  418. if (preg_match('/data-a-dynamic-image="([^"]+)"/', $html, $matches)) {
  419. $json = html_entity_decode($matches[1]);
  420. if (preg_match_all('/(https:[^"]+\.jpg)/', $json, $urlMatches)) {
  421. foreach ($urlMatches[1] as $url) {
  422. $url = str_replace('\\/', '/', $url);
  423. if ($this->isProductImage($url)) {
  424. $images[] = $url;
  425. }
  426. }
  427. }
  428. }
  430. return $images;
  431. }
  433. /**
  434. * Extrait les images depuis une page Fnac
  435. */
  436. private function extractFnacImages(string $html): array
  437. {
  438. $images = [];
  440. // Images produit Fnac
  441. if (preg_match_all('/src="(https:\/\/static\.fnac-static\.com\/multimedia\/Images\/[^"]+)"/', $html, $matches)) {
  442. foreach ($matches[1] as $url) {
  443. if ($this->isProductImage($url)) {
  444. $images[] = $url;
  445. }
  446. }
  447. }
  449. // Data-src pour lazy loading
  450. if (preg_match_all('/data-src="(https:\/\/static\.fnac-static\.com\/multimedia\/Images\/[^"]+)"/', $html, $matches)) {
  451. foreach ($matches[1] as $url) {
  452. if ($this->isProductImage($url)) {
  453. $images[] = $url;
  454. }
  455. }
  456. }
  458. return $images;
  459. }
  461. /**
  462. * Extrait les images depuis une page Babelio
  463. */
  464. private function extractBabelioImages(string $html): array
  465. {
  466. $images = [];
  468. if (preg_match_all('/src="(https:\/\/[^"]*babelio[^"]*couverture[^"]*)"/', $html, $matches)) {
  469. foreach ($matches[1] as $url) {
  470. $images[] = $url;
  471. }
  472. }
  474. return $images;
  475. }
  477. /**
  478. * Extraction générique d'images depuis une page HTML
  479. */
  480. private function extractGenericImages(string $html, string $baseUrl): array
  481. {
  482. $images = [];
  484. // Extraire toutes les images
  485. if (preg_match_all('/<img[^>]+src="([^"]+)"[^>]*>/i', $html, $matches)) {
  486. foreach ($matches[1] as $url) {
  487. // Convertir les URLs relatives en absolues
  488. if (strpos($url, 'http') !== 0) {
  489. $parsedBase = parse_url($baseUrl);
  490. $url = $parsedBase['scheme'] . '://' . $parsedBase['host'] . '/' . ltrim($url, '/');
  491. }
  493. if ($this->isProductImage($url)) {
  494. $images[] = $url;
  495. }
  496. }
  497. }
  499. return $images;
  500. }
  502. /**
  503. * Vérifie si une URL ressemble à une image de produit (pas un logo, icône, etc.)
  504. */
  505. private function isProductImage(string $url): bool
  506. {
  507. // Exclure les petites images, icônes, logos
  508. $excludePatterns = [
  509. '/sprite/',
  510. '/icon/',
  511. '/logo/',
  512. '/button/',
  513. '/pixel/',
  514. '/transparent/',
  515. '/blank/',
  516. '/1x1/',
  517. '/_SS40_',
  518. '/_SS50_',
  519. '/_SX38_',
  520. '/_SY75_',
  521. '/nav-sprite/',
  522. '/loading/',
  523. ];
  525. foreach ($excludePatterns as $pattern) {
  526. if (stripos($url, $pattern) !== false) {
  527. return false;
  528. }
  529. }
  531. // Doit être une image
  532. if (!preg_match('/\.(jpg|jpeg|png|webp|gif)/i', $url)) {
  533. return false;
  534. }
  536. return true;
  537. }
  539. public function scrapeWithPuppeteerService(?string $isbn): ?string
  540. {
  541. $isbn = $this->cleanIsbn($isbn);
  542. if (empty($isbn)) {
  543. return null;
  544. }
  546. try {
  547. $apiKey = $_ENV['PUPPETEER_API_KEY'] ?? 'votre-cle-secrete';
  548. $serviceUrl = $_ENV['PUPPETEER_SERVICE_URL'] ?? 'http://votre-serveur.com:3000';
  550. $url = "{$serviceUrl}/scrape/amazon?isbn={$isbn}";
  552. $context = stream_context_create([
  553. 'http' => [
  554. 'timeout' => 60,
  555. 'header' => "X-API-Key: {$apiKey}\r\n"
  556. ]
  557. ]);
  559. $response = @file_get_contents($url, false, $context);
  561. if ($response) {
  562. $data = json_decode($response, true);
  563. if ($data['success'] && !empty($data['imageUrl'])) {
  564. return $data['imageUrl'];
  565. }
  566. }
  567. } catch (\Exception $e) {
  568. // Log error
  569. }
  571. return null;
  572. }
  574. /**
  575. * Scrape BDGuest pour trouver l'image de couverture
  576. */
  577. public function scrapeBDGuest(?string $isbn): ?string
  578. {
  579. $isbn = $this->cleanIsbn($isbn);
  580. if (empty($isbn)) {
  581. return null;
  582. }
  584. try {
  585. $searchUrl = "https://www.bdgest.com/search.php?RechSerie={$isbn}";
  587. $context = stream_context_create([
  588. 'http' => [
  589. 'timeout' => 15,
  590. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n"
  591. ]
  592. ]);
  594. $html = @file_get_contents($searchUrl, false, $context);
  596. if ($html) {
  597. // Pattern pour les images de couverture BDGuest
  598. if (preg_match('/<img[^>]+src="(https?:\/\/[^"]*bdgest[^"]*\/Couvertures[^"]+)"/', $html, $matches)) {
  599. return $matches[1];
  600. }
  602. // Alternative: chercher dans les vignettes
  603. if (preg_match('/<img[^>]+class="[^"]*couv[^"]*"[^>]+src="([^"]+)"/', $html, $matches)) {
  604. return $matches[1];
  605. }
  606. }
  607. } catch (\Exception $e) {
  608. // Silently fail
  609. }
  611. return null;
  612. }
  614. /**
  615. * Scrape Fnac pour trouver l'image de couverture
  616. */
  617. public function scrapeFnac(?string $isbn): ?string
  618. {
  619. $isbn = $this->cleanIsbn($isbn);
  620. if (empty($isbn)) {
  621. return null;
  622. }
  624. try {
  625. $searchUrl = "https://www.fnac.com/SearchResult/ResultList.aspx?Search={$isbn}";
  627. $context = stream_context_create([
  628. 'http' => [
  629. 'timeout' => 15,
  630. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n" .
  631. "Accept: text/html,application/xhtml+xml\r\n"
  632. ]
  633. ]);
  635. $html = @file_get_contents($searchUrl, false, $context);
  637. if ($html) {
  638. // Pattern pour les images Fnac
  639. if (preg_match('/<img[^>]+data-src="(https?:\/\/[^"]*static\.fnac-static\.com[^"]*\/multimedia[^"]+)"/', $html, $matches)) {
  640. return $matches[1];
  641. }
  643. // Alternative: src direct
  644. if (preg_match('/<img[^>]+src="(https?:\/\/[^"]*static\.fnac-static\.com[^"]*\/multimedia[^"]+)"/', $html, $matches)) {
  645. return $matches[1];
  646. }
  647. }
  648. } catch (\Exception $e) {
  649. // Silently fail
  650. }
  652. return null;
  653. }
  655. /**
  656. * Scrape Decitre pour trouver l'image de couverture
  657. */
  658. public function scrapeDecitre(?string $isbn): ?string
  659. {
  660. $isbn = $this->cleanIsbn($isbn);
  661. if (empty($isbn)) {
  662. return null;
  663. }
  665. try {
  666. $searchUrl = "https://www.decitre.fr/rechercher/result?q={$isbn}";
  668. $context = stream_context_create([
  669. 'http' => [
  670. 'timeout' => 15,
  671. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n"
  672. ]
  673. ]);
  675. $html = @file_get_contents($searchUrl, false, $context);
  677. if ($html) {
  678. // Pattern pour les images Decitre
  679. if (preg_match('/<img[^>]+data-src="(https?:\/\/[^"]*products\.decitre\.fr[^"]+)"/', $html, $matches)) {
  680. return $matches[1];
  681. }
  683. if (preg_match('/<img[^>]+src="(https?:\/\/[^"]*products\.decitre\.fr[^"]+)"/', $html, $matches)) {
  684. return $matches[1];
  685. }
  686. }
  687. } catch (\Exception $e) {
  688. // Silently fail
  689. }
  691. return null;
  692. }
  694. /**
  695. * Scrape ExcaliburComics pour trouver l'image de couverture
  696. */
  697. public function scrapeExcaliburComics(?string $isbn): ?string
  698. {
  699. $isbn = $this->cleanIsbn($isbn);
  700. if (empty($isbn)) {
  701. return null;
  702. }
  704. try {
  705. $searchUrl = "https://www.excaliburcomics.fr/search?q={$isbn}";
  707. $context = stream_context_create([
  708. 'http' => [
  709. 'timeout' => 15,
  710. 'header' => "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n"
  711. ]
  712. ]);
  714. $html = @file_get_contents($searchUrl, false, $context);
  716. if ($html) {
  717. // Pattern pour les images ExcaliburComics
  718. if (preg_match('/<img[^>]+class="[^"]*product[^"]*"[^>]+src="([^"]+)"/', $html, $matches)) {
  719. $imageUrl = $matches[1];
  720. if (!str_starts_with($imageUrl, 'http')) {
  721. $imageUrl = 'https://www.excaliburcomics.fr' . $imageUrl;
  722. }
  723. return $imageUrl;
  724. }
  725. }
  726. } catch (\Exception $e) {
  727. // Silently fail
  728. }
  730. return null;
  731. }
  733. /**
  734. * Recherche la meilleure image en essayant tous les sites disponibles via Puppeteer
  735. *
  736. * @param string|null $isbn
  737. * @return array Liste de toutes les images trouvées avec leur source
  738. */
  739. public function findAllCovers(?string $isbn): array
  740. {
  741. $isbn = $this->cleanIsbn($isbn);
  742. if (empty($isbn)) {
  743. return [];
  744. }
  746. // Utiliser le service Puppeteer pour tout scraper en une fois
  747. if (!($_ENV['PUPPETEER_SERVICE_URL'] ?? false)) {
  748. return [];
  749. }
  751. try {
  752. $apiKey = $_ENV['PUPPETEER_API_KEY'] ?? 'votre-cle-secrete';
  753. $serviceUrl = $_ENV['PUPPETEER_SERVICE_URL'] ?? 'http://localhost:3000';
  755. $url = "{$serviceUrl}/scrape/all?isbn={$isbn}";
  757. $context = stream_context_create([
  758. 'http' => [
  759. 'timeout' => 120, // 2 minutes pour scraper tous les sites
  760. 'header' => "X-API-Key: {$apiKey}\r\n"
  761. ]
  762. ]);
  764. $response = @file_get_contents($url, false, $context);
  766. if ($response) {
  767. $data = json_decode($response, true);
  768. if ($data['success'] && !empty($data['images'])) {
  769. return $data['images'];
  770. }
  771. }
  772. } catch (\Exception $e) {
  773. // Log error
  774. }
  776. return [];
  777. }
  778. }