src/Service/S3Service.php line 15

1. <?php
3. namespace App\Service;
5. use Aws\Exception\AwsException;
6. use Aws\S3\S3Client;
7. use Psr\Log\LoggerInterface;
9. class S3Service
10. {
11.     private $s3Client;
12.     private $bucket;
13.     private $logger;
15.     public function __construct(LoggerInterface $logger)
16.     {
17.         $this->s3Client = new S3Client([
18.             'region' => $_ENV['AWS_REGION'],
19.             'version' => 'latest',
20.             'credentials' => [
21.                 'key' => $_ENV['AWS_ACCESS_KEY_ID'],
22.                 'secret' => $_ENV['AWS_SECRET_ACCESS_KEY'],
23.             ],
24.         ]);
25.         $this->bucket = $_ENV['AWS_BUCKET_NAME'];
26.         $this->logger = $logger;
27.     }
29.     /**
30.      * Valide qu'une clé S3 n'est pas vide
31.      */
32.     private function validateKey($key)
33.     {
34.         if (empty($key) || trim($key) === '') {
35.             throw new \InvalidArgumentException('La clé S3 ne peut pas être vide');
36.         }
37.         return trim($key);
38.     }
40.     public function listFiles($prefix = '')
41.     {
42.         try {
43.             $objects = $this->s3Client->listObjectsV2([
44.                 'Bucket' => $this->bucket,
45.                 'Prefix' => $prefix,
46.             ]);
47.             return $objects['Contents'] ?? [];
48.         } catch (\Exception $e) {
49.             $this->logger->error("Erreur lors de la récupération des fichiers S3 : " . $e->getMessage());
50.             return [];
51.         }
52.     }
54.     public function uploadDocument($content, $key)
55.     {
56.         try {
57.             // Validation et nettoyage de la clé
58.             $cleanKey = $this->validateKey($key);
59.             $cleanKey = str_replace(" ", "_", $cleanKey);
61.             $result = $this->s3Client->putObject([
62.                 'Bucket' => $this->bucket,
63.                 'Key' => $cleanKey,
64.                 'Body' => $content,
65.                 'ACL' => 'private',
66.                 'ServerSideEncryption' => 'AES256',
67.             ]);
68.             return $result->get('ObjectURL') ?? $result->get('Location');
70.         } catch (\InvalidArgumentException $e) {
71.             $this->logger->error("Clé S3 invalide : " . $e->getMessage());
72.             return false;
73.         } catch (\Exception $e) {
74.             $this->logger->error("Erreur lors de l'upload vers S3 : " . $e->getMessage());
75.             return false;
76.         }
77.     }
79.     public function downloadDocument($s3Key)
80.     {
81.         try {
82.             // Validation de la clé avant utilisation
83.             $cleanKey = $this->validateKey($s3Key);
85.             $result = $this->s3Client->getObject([
86.                 'Bucket' => $this->bucket,
87.                 'Key' => $cleanKey,
88.             ]);
89.             return $result['Body'];
90.         } catch (\InvalidArgumentException $e) {
91.             $this->logger->error("Clé S3 invalide pour le téléchargement : " . $e->getMessage());
92.             return false;
93.         } catch (AwsException $e) {
94.             $this->logger->error("Erreur AWS lors du téléchargement : " . $e->getMessage());
95.             return false;
96.         }
97.     }
99.     public function getSignedUrl($key, $expiration = '+1 hour')
100.     {
101.         try {
102.             // Validation de la clé
103.             $cleanKey = $this->validateKey($key);
105.             $command = $this->s3Client->getCommand('GetObject', [
106.                 'Bucket' => $this->bucket,
107.                 'Key' => $cleanKey,
108.             ]);
110.             $signedUrl = $this->s3Client->createPresignedRequest($command, $expiration)->getUri();
111.             return (string)$signedUrl;
112.         } catch (\InvalidArgumentException $e) {
113.             $this->logger->error("Clé S3 invalide pour l'URL signée : " . $e->getMessage());
114.             return false;
115.         } catch (\Exception $e) {
116.             $this->logger->error("Erreur lors de la génération de l'URL signée : " . $e->getMessage());
117.             return false;
118.         }
119.     }
121.     public function getJson($key)
122.     {
123.         try {
124.             // Validation de la clé
125.             $cleanKey = $this->validateKey($key);
127.             $result = $this->s3Client->getObject([
128.                 'Bucket' => $this->bucket,
129.                 'Key' => $cleanKey,
130.             ]);
131.             return json_decode($result['Body'], true);
132.         } catch (\InvalidArgumentException $e) {
133.             $this->logger->error("Clé S3 invalide pour le JSON : " . $e->getMessage());
134.             throw $e;
135.         } catch (\Exception $e) {
136.             $this->logger->error("Erreur lors de la récupération du JSON depuis S3 : " . $e->getMessage());
137.             throw $e;
138.         }
139.     }
141.     public function extractKeyFromUrl($url)
142.     {
143.         if (empty($url)) {
144.             return '';
145.         }
147.         $parsedUrl = parse_url($url);
148.         if (isset($parsedUrl['path'])) {
149.             // Supprime le premier slash initial "/" et les slashes multiples
150.             $key = ltrim($parsedUrl['path'], '/');
151.             // Nettoie les slashes doubles
152.             $key = preg_replace('/\/+/', '/', $key);
153.             return $key;
154.         }
155.         return $url;
156.     }
158.     public function getFileFromS3($fileName)
159.     {
160.         try {
161.             // Validation de la clé
162.             $cleanFileName = $this->validateKey($fileName);
164.             $result = $this->s3Client->getObject([
165.                 'Bucket' => $this->bucket,
166.                 'Key' => $cleanFileName,
167.             ]);
169.             return $result['Body'];
171.         } catch (\InvalidArgumentException $e) {
172.             $this->logger->error("Nom de fichier S3 invalide : " . $e->getMessage());
173.             return null;
174.         } catch (AwsException $e) {
175.             $this->logger->error("Error retrieving file from S3: " . $e->getMessage());
176.             return null;
177.         }
178.     }
180.     /**
181.      * Vérifie si un objet existe dans S3
182.      */
183.     public function objectExists($key)
184.     {
185.         try {
186.             $cleanKey = $this->validateKey($key);
188.             $this->s3Client->headObject([
189.                 'Bucket' => $this->bucket,
190.                 'Key' => $cleanKey,
191.             ]);
192.             return true;
193.         } catch (\Exception $e) {
194.             return false;
195.         }
196.     }
197. }