xref: /webtrees/app/Services/MediaFileService.php (revision e68d818ecc7cffbe56dcc982d6ecfbc7075fa448) 
1<?php
2
3/**
4 * webtrees: online genealogy
5 * Copyright (C) 2021 webtrees development team
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 */
17
18declare(strict_types=1);
19
20namespace Fisharebest\Webtrees\Services;
21
22use Fisharebest\Webtrees\FlashMessages;
23use Fisharebest\Webtrees\I18N;
24use Fisharebest\Webtrees\Registry;
25use Fisharebest\Webtrees\Tree;
26use Illuminate\Database\Capsule\Manager as DB;
27use Illuminate\Database\Query\Expression;
28use Illuminate\Database\Query\JoinClause;
29use Illuminate\Support\Collection;
30use InvalidArgumentException;
31use League\Flysystem\Filesystem;
32use League\Flysystem\FilesystemException;
33use League\Flysystem\FilesystemOperator;
34use League\Flysystem\StorageAttributes;
35use Psr\Http\Message\ServerRequestInterface;
36use Psr\Http\Message\UploadedFileInterface;
37use RuntimeException;
38
39use function array_combine;
40use function array_diff;
41use function assert;
42use function dirname;
43use function ini_get;
44use function intdiv;
45use function min;
46use function pathinfo;
47use function preg_replace;
48use function sha1;
49use function sort;
50use function str_contains;
51use function str_ends_with;
52use function str_starts_with;
53use function strtolower;
54use function strtr;
55use function substr;
56use function trim;
57
58use const PATHINFO_EXTENSION;
59use const UPLOAD_ERR_OK;
60
61/**
62 * Managing media files.
63 */
64class MediaFileService
65{
66    public const EDIT_RESTRICTIONS = [
67        'locked',
68    ];
69
70    public const PRIVACY_RESTRICTIONS = [
71        'none',
72        'privacy',
73        'confidential',
74    ];
75
76    public const EXTENSION_TO_FORM = [
77        'jpeg' => 'jpg',
78        'tiff' => 'tif',
79    ];
80
81    /**
82     * What is the largest file a user may upload?
83     */
84    public function maxUploadFilesize(): string
85    {
86        $sizePostMax = $this->parseIniFileSize(ini_get('post_max_size'));
87        $sizeUploadMax = $this->parseIniFileSize(ini_get('upload_max_filesize'));
88
89        $bytes =  min($sizePostMax, $sizeUploadMax);
90        $kb    = intdiv($bytes + 1023, 1024);
91
92        return I18N::translate('%s KB', I18N::number($kb));
93    }
94
95    /**
96     * Returns the given size from an ini value in bytes.
97     *
98     * @param string $size
99     *
100     * @return int
101     */
102    private function parseIniFileSize(string $size): int
103    {
104        $number = (int) $size;
105
106        switch (substr($size, -1)) {
107            case 'g':
108            case 'G':
109                return $number * 1073741824;
110            case 'm':
111            case 'M':
112                return $number * 1048576;
113            case 'k':
114            case 'K':
115                return $number * 1024;
116            default:
117                return $number;
118        }
119    }
120
121    /**
122     * A list of media files not already linked to a media object.
123     *
124     * @param Tree               $tree
125     * @param FilesystemOperator $data_filesystem
126     *
127     * @return array<string>
128     */
129    public function unusedFiles(Tree $tree, FilesystemOperator $data_filesystem): array
130    {
131        $used_files = DB::table('media_file')
132            ->where('m_file', '=', $tree->id())
133            ->where('multimedia_file_refn', 'NOT LIKE', 'http://%')
134            ->where('multimedia_file_refn', 'NOT LIKE', 'https://%')
135            ->pluck('multimedia_file_refn')
136            ->all();
137
138        $media_filesystem = $disk_files = $tree->mediaFilesystem($data_filesystem);
139        $disk_files       = $this->allFilesOnDisk($media_filesystem, '', Filesystem::LIST_DEEP)->all();
140        $unused_files     = array_diff($disk_files, $used_files);
141
142        sort($unused_files);
143
144        return array_combine($unused_files, $unused_files);
145    }
146
147    /**
148     * Store an uploaded file (or URL), either to be added to a media object
149     * or to create a media object.
150     *
151     * @param ServerRequestInterface $request
152     *
153     * @return string The value to be stored in the 'FILE' field of the media object.
154     * @throws FilesystemException
155     */
156    public function uploadFile(ServerRequestInterface $request): string
157    {
158        $tree = $request->getAttribute('tree');
159        assert($tree instanceof Tree);
160
161        $data_filesystem = Registry::filesystem()->data();
162
163        $params        = (array) $request->getParsedBody();
164        $file_location = $params['file_location'];
165
166        switch ($file_location) {
167            case 'url':
168                $remote = $params['remote'];
169
170                if (str_contains($remote, '://')) {
171                    return $remote;
172                }
173
174                return '';
175
176            case 'unused':
177                $unused = $params['unused'];
178
179                if ($tree->mediaFilesystem($data_filesystem)->fileExists($unused)) {
180                    return $unused;
181                }
182
183                return '';
184
185            case 'upload':
186            default:
187                $folder   = $params['folder'];
188                $auto     = $params['auto'];
189                $new_file = $params['new_file'];
190
191                /** @var UploadedFileInterface|null $uploaded_file */
192                $uploaded_file = $request->getUploadedFiles()['file'];
193                if ($uploaded_file === null || $uploaded_file->getError() !== UPLOAD_ERR_OK) {
194                    return '';
195                }
196
197                // The filename
198                $new_file = strtr($new_file, ['\\' => '/']);
199                if ($new_file !== '' && !str_contains($new_file, '/')) {
200                    $file = $new_file;
201                } else {
202                    $file = $uploaded_file->getClientFilename();
203                }
204
205                // The folder
206                $folder = strtr($folder, ['\\' => '/']);
207                $folder = trim($folder, '/');
208                if ($folder !== '') {
209                    $folder .= '/';
210                }
211
212                // Generate a unique name for the file?
213                if ($auto === '1' || $tree->mediaFilesystem($data_filesystem)->fileExists($folder . $file)) {
214                    $folder    = '';
215                    $extension = pathinfo($uploaded_file->getClientFilename(), PATHINFO_EXTENSION);
216                    $file      = sha1((string) $uploaded_file->getStream()) . '.' . $extension;
217                }
218
219                try {
220                    $tree->mediaFilesystem($data_filesystem)->writeStream($folder . $file, $uploaded_file->getStream()->detach());
221
222                    return $folder . $file;
223                } catch (RuntimeException | InvalidArgumentException $ex) {
224                    FlashMessages::addMessage(I18N::translate('There was an error uploading your file.'));
225
226                    return '';
227                }
228        }
229    }
230
231    /**
232     * Convert the media file attributes into GEDCOM format.
233     *
234     * @param string $file
235     * @param string $type
236     * @param string $title
237     * @param string $note
238     *
239     * @return string
240     */
241    public function createMediaFileGedcom(string $file, string $type, string $title, string $note): string
242    {
243        // Tidy non-printing characters
244        $type  = trim(preg_replace('/\s+/', ' ', $type));
245        $title = trim(preg_replace('/\s+/', ' ', $title));
246
247        $gedcom = '1 FILE ' . $file;
248
249        $format = strtolower(pathinfo($file, PATHINFO_EXTENSION));
250        $format = self::EXTENSION_TO_FORM[$format] ?? $format;
251
252        if ($format !== '') {
253            $gedcom .= "\n2 FORM " . $format;
254        } elseif ($type !== '') {
255            $gedcom .= "\n2 FORM";
256        }
257
258        if ($type !== '') {
259            $gedcom .= "\n3 TYPE " . $type;
260        }
261
262        if ($title !== '') {
263            $gedcom .= "\n2 TITL " . $title;
264        }
265
266        if ($note !== '') {
267            // Convert HTML line endings to GEDCOM continuations
268            $gedcom .= "\n1 NOTE " . strtr($note, ["\r\n" => "\n2 CONT "]);
269        }
270
271        return $gedcom;
272    }
273
274    /**
275     * Fetch a list of all files on disk (in folders used by any tree).
276     *
277     * @param FilesystemOperator $filesystem $filesystem to search
278     * @param string             $folder     Root folder
279     * @param bool               $subfolders Include subfolders
280     *
281     * @return Collection<string>
282     */
283    public function allFilesOnDisk(FilesystemOperator $filesystem, string $folder, bool $subfolders): Collection
284    {
285        try {
286            $files = $filesystem->listContents($folder, $subfolders)
287                ->filter(function (StorageAttributes $attributes): bool {
288                    return $attributes->isFile() && !$this->isLegacyFolder($attributes->path());
289                })
290                ->map(static function (StorageAttributes $attributes): string {
291                    return $attributes->path();
292                })
293                ->toArray();
294        } catch (FilesystemException $ex) {
295            $files = [];
296        }
297
298        return new Collection($files);
299    }
300
301    /**
302     * Fetch a list of all files on in the database.
303     *
304     * @param string $media_folder Root folder
305     * @param bool   $subfolders   Include subfolders
306     *
307     * @return Collection<string>
308     */
309    public function allFilesInDatabase(string $media_folder, bool $subfolders): Collection
310    {
311        $query = DB::table('media_file')
312            ->join('gedcom_setting', 'gedcom_id', '=', 'm_file')
313            ->where('setting_name', '=', 'MEDIA_DIRECTORY')
314            //->where('multimedia_file_refn', 'LIKE', '%/%')
315            ->where('multimedia_file_refn', 'NOT LIKE', 'http://%')
316            ->where('multimedia_file_refn', 'NOT LIKE', 'https://%')
317            ->where(new Expression('setting_value || multimedia_file_refn'), 'LIKE', $media_folder . '%')
318            ->select(new Expression('setting_value || multimedia_file_refn AS path'))
319            ->orderBy(new Expression('setting_value || multimedia_file_refn'));
320
321        if (!$subfolders) {
322            $query->where(new Expression('setting_value || multimedia_file_refn'), 'NOT LIKE', $media_folder . '%/%');
323        }
324
325        return $query->pluck('path');
326    }
327
328    /**
329     * Generate a list of all folders in either the database or the filesystem.
330     *
331     * @param FilesystemOperator $data_filesystem
332     *
333     * @return Collection<string,string>
334     * @throws FilesystemException
335     */
336    public function allMediaFolders(FilesystemOperator $data_filesystem): Collection
337    {
338        $db_folders = DB::table('media_file')
339            ->leftJoin('gedcom_setting', static function (JoinClause $join): void {
340                $join
341                    ->on('gedcom_setting.gedcom_id', '=', 'media.m_file')
342                    ->where('setting_name', '=', 'MEDIA_DIRECTORY');
343            })
344            ->where('multimedia_file_refn', 'NOT LIKE', 'http://%')
345            ->where('multimedia_file_refn', 'NOT LIKE', 'https://%')
346            ->select(new Expression("COALESCE(setting_value, 'media/') || multimedia_file_refn AS path"))
347            ->pluck('path')
348            ->map(static function (string $path): string {
349                return dirname($path) . '/';
350            });
351
352        $media_roots = DB::table('gedcom_setting')
353            ->where('setting_name', '=', 'MEDIA_DIRECTORY')
354            ->where('gedcom_id', '>', '0')
355            ->pluck('setting_value')
356            ->uniqueStrict();
357
358        $disk_folders = new Collection($media_roots);
359
360        foreach ($media_roots as $media_folder) {
361            $tmp = $data_filesystem->listContents($media_folder, Filesystem::LIST_DEEP)
362                ->filter(function (StorageAttributes $attributes): bool {
363                    return $attributes->isDir() && !$this->isLegacyFolder($attributes->path());
364                })
365                ->map(static function (StorageAttributes $attributes): string {
366                    return $attributes->path() . '/';
367                })
368                ->toArray();
369
370            $disk_folders = $disk_folders->concat($tmp);
371        }
372
373        return $disk_folders->concat($db_folders)
374            ->uniqueStrict()
375            ->mapWithKeys(static function (string $folder): array {
376                return [$folder => $folder];
377            });
378    }
379
380    /**
381     * Some special media folders were created by earlier versions of webtrees.
382     *
383     * @param string $path
384     *
385     * @return bool
386     */
387    private function isLegacyFolder(string $path): bool
388    {
389        return
390            str_starts_with($path, 'thumbs/') ||
391            str_contains($path, '/thumbs/') ||
392            str_ends_with($path, '/thumbs') ||
393            str_starts_with($path, 'watermarks/') ||
394            str_contains($path, '/watermarks/') ||
395            str_ends_with($path, '/watermarks');
396    }
397}
398