├── LICENSE.md
├── README.md
├── composer.json
├── config
└── media-library.php
├── database
└── migrations
│ └── create_media_table.php.stub
├── resources
└── views
│ ├── image.blade.php
│ ├── placeholderSvg.blade.php
│ ├── responsiveImage.blade.php
│ └── responsiveImageWithPlaceholder.blade.php
└── src
├── Conversions
├── Actions
│ ├── PerformConversionAction.php
│ └── PerformManipulationsAction.php
├── Commands
│ └── RegenerateCommand.php
├── Conversion.php
├── ConversionCollection.php
├── Events
│ ├── ConversionHasBeenCompletedEvent.php
│ └── ConversionWillStartEvent.php
├── FileManipulator.php
├── ImageGenerators
│ ├── Avif.php
│ ├── Image.php
│ ├── ImageGenerator.php
│ ├── ImageGeneratorFactory.php
│ ├── Pdf.php
│ ├── Svg.php
│ ├── Video.php
│ └── Webp.php
├── Jobs
│ └── PerformConversionsJob.php
└── Manipulations.php
├── Downloaders
├── DefaultDownloader.php
├── Downloader.php
└── HttpFacadeDownloader.php
├── Enums
└── CollectionPosition.php
├── HasMedia.php
├── InteractsWithMedia.php
├── MediaCollections
├── Commands
│ ├── CleanCommand.php
│ └── ClearCommand.php
├── Contracts
│ └── MediaLibraryRequest.php
├── Events
│ ├── CollectionHasBeenClearedEvent.php
│ └── MediaHasBeenAddedEvent.php
├── Exceptions
│ ├── DiskCannotBeAccessed.php
│ ├── DiskDoesNotExist.php
│ ├── FileCannotBeAdded.php
│ ├── FileDoesNotExist.php
│ ├── FileIsTooBig.php
│ ├── FileNameNotAllowed.php
│ ├── FileUnacceptableForCollection.php
│ ├── FunctionalityNotAvailable.php
│ ├── InvalidBase64Data.php
│ ├── InvalidConversion.php
│ ├── InvalidFileRemover.php
│ ├── InvalidPathGenerator.php
│ ├── InvalidUrl.php
│ ├── InvalidUrlGenerator.php
│ ├── MediaCannotBeDeleted.php
│ ├── MediaCannotBeUpdated.php
│ ├── MimeTypeNotAllowed.php
│ ├── RequestDoesNotHaveFile.php
│ ├── UnknownType.php
│ └── UnreachableUrl.php
├── File.php
├── FileAdder.php
├── FileAdderFactory.php
├── Filesystem.php
├── HtmlableMedia.php
├── MediaCollection.php
├── MediaRepository.php
└── Models
│ ├── Collections
│ └── MediaCollection.php
│ ├── Concerns
│ ├── CustomMediaProperties.php
│ ├── HasUuid.php
│ └── IsSorted.php
│ ├── Media.php
│ └── Observers
│ └── MediaObserver.php
├── MediaLibraryServiceProvider.php
├── ResponsiveImages
├── Events
│ └── ResponsiveImagesGeneratedEvent.php
├── Exceptions
│ └── InvalidTinyJpg.php
├── Jobs
│ └── GenerateResponsiveImagesJob.php
├── RegisteredResponsiveImages.php
├── ResponsiveImage.php
├── ResponsiveImageGenerator.php
├── TinyPlaceholderGenerator
│ ├── Blurred.php
│ └── TinyPlaceholderGenerator.php
└── WidthCalculator
│ ├── FileSizeOptimizedWidthCalculator.php
│ └── WidthCalculator.php
└── Support
├── Factories
└── TemporaryUploadFactory.php
├── File.php
├── FileNamer
├── DefaultFileNamer.php
└── FileNamer.php
├── FileRemover
├── DefaultFileRemover.php
├── FileBaseFileRemover.php
├── FileRemover.php
└── FileRemoverFactory.php
├── ImageFactory.php
├── MediaLibraryPro.php
├── MediaStream.php
├── PathGenerator
├── DefaultPathGenerator.php
├── PathGenerator.php
└── PathGeneratorFactory.php
├── RemoteFile.php
├── TemporaryDirectory.php
└── UrlGenerator
├── BaseUrlGenerator.php
├── DefaultUrlGenerator.php
├── UrlGenerator.php
└── UrlGeneratorFactory.php
/LICENSE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) Spatie bvba <info@spatie.be>
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | <div align="left">
2 | <a href="https://spatie.be/open-source?utm_source=github&utm_medium=banner&utm_campaign=laravel-medialibrary">
3 | <picture>
4 | <source media="(prefers-color-scheme: dark)" srcset="https://spatie.be/packages/header/laravel-medialibrary/html/dark.webp">
5 | <img alt="Logo for laravel-medialibrary" src="https://spatie.be/packages/header/laravel-medialibrary/html/light.webp">
6 | </picture>
7 | </a>
8 |
9 | <h1>Associate files with Eloquent models</h1>
10 |
11 | [](https://github.com/spatie/laravel-medialibrary/releases)
12 | [](https://github.com/spatie/laravel-medialibrary/actions/workflows/run-tests.yml)
13 | [](https://packagist.org/packages/spatie/laravel-medialibrary)
14 |
15 | </div>
16 |
17 | This package can associate all sorts of files with Eloquent models. It provides a
18 | simple API to work with. To learn all about it, head over to [the extensive documentation](https://spatie.be/docs/laravel-medialibrary).
19 |
20 | Here are a few short examples of what you can do:
21 |
22 | ```php
23 | $newsItem = News::find(1);
24 | $newsItem->addMedia($pathToFile)->toMediaCollection('images');
25 | ```
26 |
27 | It can handle your uploads directly:
28 |
29 | ```php
30 | $newsItem->addMedia($request->file('image'))->toMediaCollection('images');
31 | ```
32 |
33 | Want to store some large files on another filesystem? No problem:
34 |
35 | ```php
36 | $newsItem->addMedia($smallFile)->toMediaCollection('downloads', 'local');
37 | $newsItem->addMedia($bigFile)->toMediaCollection('downloads', 's3');
38 | ```
39 |
40 | The storage of the files is handled by [Laravel's Filesystem](https://laravel.com/docs/filesystem),
41 | so you can use any filesystem you like. Additionally, the package can create image manipulations
42 | on images and pdfs that have been added in the media library.
43 |
44 | Spatie is a webdesign agency in Antwerp, Belgium. You'll find an overview of all our open source projects [on our website](https://spatie.be/opensource).
45 |
46 | ## Support us
47 |
48 | [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/laravel-medialibrary.jpg?t=2" width="419px" />](https://spatie.be/github-ad-click/laravel-medialibrary)
49 |
50 | We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us).
51 |
52 | We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards).
53 |
54 | ## Documentation
55 |
56 | You'll find the documentation on [https://spatie.be/docs/laravel-medialibrary](https://spatie.be/docs/laravel-medialibrary/v11).
57 |
58 | Find yourself stuck using the package? Found a bug? Do you have general questions or suggestions for improving the media library? Feel free to [create an issue on GitHub](https://github.com/spatie/laravel-medialibrary/issues), we'll try to address it as soon as possible.
59 |
60 | If you've found a bug regarding security please mail [security@spatie.be](mailto:security@spatie.be) instead of using the issue tracker.
61 |
62 | ## Testing
63 |
64 | You can run the tests with:
65 |
66 | ```bash
67 | ./vendor/bin/pest
68 | ```
69 |
70 | You can run the Github actions locally with [act](https://github.com/nektos/act). To run the tests locally, run:
71 |
72 | ```
73 | act -j run-tests
74 | ```
75 |
76 | To run tests for a specific PHP/Laravel version, run:
77 |
78 | ```
79 | act -j run-tests --matrix php:8.3 --matrix laravel:"11.*" --matrix dependency-version:prefer-stable
80 | ```
81 |
82 | Available `matrix` options are available in the [workflow file](.github/workflows/run-tests.yml).
83 |
84 | ## Upgrading
85 |
86 | Please see [UPGRADING](UPGRADING.md) for details.
87 |
88 | ### Changelog
89 |
90 | Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.
91 |
92 | ## Contributing
93 |
94 | Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details.
95 |
96 | ## Security
97 |
98 | If you discover any security related issues, please email [security@spatie.be](mailto:security@spatie.be) instead of using the issue tracker.
99 |
100 | ## Credits
101 |
102 | - [Freek Van der Herten](https://github.com/freekmurze)
103 | - [All Contributors](../../contributors)
104 |
105 | A big thank you to [Nicolas Beauvais](https://github.com/nicolasbeauvais) for helping out with the issues on this repo.
106 |
107 | Special thanks to [Caneco](https://twitter.com/caneco) for the original logo.
108 |
109 | ## Alternatives
110 |
111 | - [laravel-mediable](https://github.com/plank/laravel-mediable)
112 | - [laravel-stapler](https://github.com/CodeSleeve/laravel-stapler)
113 | - [media-manager](https://github.com/talvbansal/media-manager)
114 |
115 | ## License
116 |
117 | The MIT License (MIT). Please see [License File](LICENSE.md) for more information.
118 |
--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "spatie/laravel-medialibrary",
3 | "description": "Associate files with Eloquent models",
4 | "license": "MIT",
5 | "keywords": [
6 | "spatie",
7 | "laravel-medialibrary",
8 | "media",
9 | "conversion",
10 | "images",
11 | "downloads",
12 | "cms",
13 | "laravel"
14 | ],
15 | "authors": [
16 | {
17 | "name": "Freek Van der Herten",
18 | "email": "freek@spatie.be",
19 | "homepage": "https://spatie.be",
20 | "role": "Developer"
21 | }
22 | ],
23 | "homepage": "https://github.com/spatie/laravel-medialibrary",
24 | "require": {
25 | "php": "^8.2",
26 | "ext-exif": "*",
27 | "ext-fileinfo": "*",
28 | "ext-json": "*",
29 | "composer/semver": "^3.4",
30 | "illuminate/bus": "^10.2|^11.0|^12.0",
31 | "illuminate/conditionable": "^10.2|^11.0|^12.0",
32 | "illuminate/console": "^10.2|^11.0|^12.0",
33 | "illuminate/database": "^10.2|^11.0|^12.0",
34 | "illuminate/pipeline": "^10.2|^11.0|^12.0",
35 | "illuminate/support": "^10.2|^11.0|^12.0",
36 | "maennchen/zipstream-php": "^3.1",
37 | "spatie/image": "^3.3.2",
38 | "spatie/laravel-package-tools": "^1.16.1",
39 | "spatie/temporary-directory": "^2.2",
40 | "symfony/console": "^6.4.1|^7.0"
41 | },
42 | "require-dev": {
43 | "ext-imagick": "*",
44 | "ext-pdo_sqlite": "*",
45 | "ext-zip": "*",
46 | "aws/aws-sdk-php": "^3.293.10",
47 | "guzzlehttp/guzzle": "^7.8.1",
48 | "league/flysystem-aws-s3-v3": "^3.22",
49 | "mockery/mockery": "^1.6.7",
50 | "larastan/larastan": "^2.7|^3.0",
51 | "orchestra/testbench": "^7.0|^8.17|^9.0|^10.0",
52 | "pestphp/pest": "^2.28|^3.5",
53 | "phpstan/extension-installer": "^1.3.1",
54 | "spatie/laravel-ray": "^1.33",
55 | "spatie/pdf-to-image": "^2.2|^3.0",
56 | "spatie/pest-plugin-snapshots": "^2.1"
57 | },
58 | "conflict": {
59 | "php-ffmpeg/php-ffmpeg": "<0.6.1"
60 | },
61 | "suggest": {
62 | "league/flysystem-aws-s3-v3": "Required to use AWS S3 file storage",
63 | "php-ffmpeg/php-ffmpeg": "Required for generating video thumbnails",
64 | "spatie/pdf-to-image": "Required for generating thumbnails of PDFs and SVGs"
65 | },
66 | "minimum-stability": "dev",
67 | "prefer-stable": true,
68 | "autoload": {
69 | "psr-4": {
70 | "Spatie\\MediaLibrary\\": "src"
71 | }
72 | },
73 | "autoload-dev": {
74 | "psr-4": {
75 | "Spatie\\MediaLibrary\\Tests\\": "tests"
76 | }
77 | },
78 | "config": {
79 | "allow-plugins": {
80 | "pestphp/pest-plugin": true,
81 | "phpstan/extension-installer": true
82 | },
83 | "sort-packages": true
84 | },
85 | "extra": {
86 | "laravel": {
87 | "providers": [
88 | "Spatie\\MediaLibrary\\MediaLibraryServiceProvider"
89 | ]
90 | }
91 | },
92 | "scripts": {
93 | "analyse": "vendor/bin/phpstan analyse",
94 | "baseline": "vendor/bin/phpstan analyse --generate-baseline",
95 | "test": "vendor/bin/pest"
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/config/media-library.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | return [
4 |
5 | /*
6 | * The disk on which to store added files and derived images by default. Choose
7 | * one or more of the disks you've configured in config/filesystems.php.
8 | */
9 | 'disk_name' => env('MEDIA_DISK', 'public'),
10 |
11 | /*
12 | * The maximum file size of an item in bytes.
13 | * Adding a larger file will result in an exception.
14 | */
15 | 'max_file_size' => 1024 * 1024 * 10, // 10MB
16 |
17 | /*
18 | * This queue connection will be used to generate derived and responsive images.
19 | * Leave empty to use the default queue connection.
20 | */
21 | 'queue_connection_name' => env('QUEUE_CONNECTION', 'sync'),
22 |
23 | /*
24 | * This queue will be used to generate derived and responsive images.
25 | * Leave empty to use the default queue.
26 | */
27 | 'queue_name' => env('MEDIA_QUEUE', ''),
28 |
29 | /*
30 | * By default all conversions will be performed on a queue.
31 | */
32 | 'queue_conversions_by_default' => env('QUEUE_CONVERSIONS_BY_DEFAULT', true),
33 |
34 | /*
35 | * Should database transactions be run after database commits?
36 | */
37 | 'queue_conversions_after_database_commit' => env('QUEUE_CONVERSIONS_AFTER_DB_COMMIT', true),
38 |
39 | /*
40 | * The fully qualified class name of the media model.
41 | */
42 | 'media_model' => Spatie\MediaLibrary\MediaCollections\Models\Media::class,
43 |
44 | /*
45 | * The fully qualified class name of the media observer.
46 | */
47 | 'media_observer' => Spatie\MediaLibrary\MediaCollections\Models\Observers\MediaObserver::class,
48 |
49 | /*
50 | * When enabled, media collections will be serialised using the default
51 | * laravel model serialization behaviour.
52 | *
53 | * Keep this option disabled if using Media Library Pro components (https://medialibrary.pro)
54 | */
55 | 'use_default_collection_serialization' => false,
56 |
57 | /*
58 | * The fully qualified class name of the model used for temporary uploads.
59 | *
60 | * This model is only used in Media Library Pro (https://medialibrary.pro)
61 | */
62 | 'temporary_upload_model' => Spatie\MediaLibraryPro\Models\TemporaryUpload::class,
63 |
64 | /*
65 | * When enabled, Media Library Pro will only process temporary uploads that were uploaded
66 | * in the same session. You can opt to disable this for stateless usage of
67 | * the pro components.
68 | */
69 | 'enable_temporary_uploads_session_affinity' => true,
70 |
71 | /*
72 | * When enabled, Media Library pro will generate thumbnails for uploaded file.
73 | */
74 | 'generate_thumbnails_for_temporary_uploads' => true,
75 |
76 | /*
77 | * This is the class that is responsible for naming generated files.
78 | */
79 | 'file_namer' => Spatie\MediaLibrary\Support\FileNamer\DefaultFileNamer::class,
80 |
81 | /*
82 | * The class that contains the strategy for determining a media file's path.
83 | */
84 | 'path_generator' => Spatie\MediaLibrary\Support\PathGenerator\DefaultPathGenerator::class,
85 |
86 | /*
87 | * The class that contains the strategy for determining how to remove files.
88 | */
89 | 'file_remover_class' => Spatie\MediaLibrary\Support\FileRemover\DefaultFileRemover::class,
90 |
91 | /*
92 | * Here you can specify which path generator should be used for the given class.
93 | */
94 | 'custom_path_generators' => [
95 | // Model::class => PathGenerator::class
96 | // or
97 | // 'model_morph_alias' => PathGenerator::class
98 | ],
99 |
100 | /*
101 | * When urls to files get generated, this class will be called. Use the default
102 | * if your files are stored locally above the site root or on s3.
103 | */
104 | 'url_generator' => Spatie\MediaLibrary\Support\UrlGenerator\DefaultUrlGenerator::class,
105 |
106 | /*
107 | * Moves media on updating to keep path consistent. Enable it only with a custom
108 | * PathGenerator that uses, for example, the media UUID.
109 | */
110 | 'moves_media_on_update' => false,
111 |
112 | /*
113 | * Whether to activate versioning when urls to files get generated.
114 | * When activated, this attaches a ?v=xx query string to the URL.
115 | */
116 | 'version_urls' => false,
117 |
118 | /*
119 | * The media library will try to optimize all converted images by removing
120 | * metadata and applying a little bit of compression. These are
121 | * the optimizers that will be used by default.
122 | */
123 | 'image_optimizers' => [
124 | Spatie\ImageOptimizer\Optimizers\Jpegoptim::class => [
125 | '-m85', // set maximum quality to 85%
126 | '--force', // ensure that progressive generation is always done also if a little bigger
127 | '--strip-all', // this strips out all text information such as comments and EXIF data
128 | '--all-progressive', // this will make sure the resulting image is a progressive one
129 | ],
130 | Spatie\ImageOptimizer\Optimizers\Pngquant::class => [
131 | '--force', // required parameter for this package
132 | ],
133 | Spatie\ImageOptimizer\Optimizers\Optipng::class => [
134 | '-i0', // this will result in a non-interlaced, progressive scanned image
135 | '-o2', // this set the optimization level to two (multiple IDAT compression trials)
136 | '-quiet', // required parameter for this package
137 | ],
138 | Spatie\ImageOptimizer\Optimizers\Svgo::class => [
139 | '--disable=cleanupIDs', // disabling because it is known to cause troubles
140 | ],
141 | Spatie\ImageOptimizer\Optimizers\Gifsicle::class => [
142 | '-b', // required parameter for this package
143 | '-O3', // this produces the slowest but best results
144 | ],
145 | Spatie\ImageOptimizer\Optimizers\Cwebp::class => [
146 | '-m 6', // for the slowest compression method in order to get the best compression.
147 | '-pass 10', // for maximizing the amount of analysis pass.
148 | '-mt', // multithreading for some speed improvements.
149 | '-q 90', // quality factor that brings the least noticeable changes.
150 | ],
151 | Spatie\ImageOptimizer\Optimizers\Avifenc::class => [
152 | '-a cq-level=23', // constant quality level, lower values mean better quality and greater file size (0-63).
153 | '-j all', // number of jobs (worker threads, "all" uses all available cores).
154 | '--min 0', // min quantizer for color (0-63).
155 | '--max 63', // max quantizer for color (0-63).
156 | '--minalpha 0', // min quantizer for alpha (0-63).
157 | '--maxalpha 63', // max quantizer for alpha (0-63).
158 | '-a end-usage=q', // rate control mode set to Constant Quality mode.
159 | '-a tune=ssim', // SSIM as tune the encoder for distortion metric.
160 | ],
161 | ],
162 |
163 | /*
164 | * These generators will be used to create an image of media files.
165 | */
166 | 'image_generators' => [
167 | Spatie\MediaLibrary\Conversions\ImageGenerators\Image::class,
168 | Spatie\MediaLibrary\Conversions\ImageGenerators\Webp::class,
169 | Spatie\MediaLibrary\Conversions\ImageGenerators\Avif::class,
170 | Spatie\MediaLibrary\Conversions\ImageGenerators\Pdf::class,
171 | Spatie\MediaLibrary\Conversions\ImageGenerators\Svg::class,
172 | Spatie\MediaLibrary\Conversions\ImageGenerators\Video::class,
173 | ],
174 |
175 | /*
176 | * The path where to store temporary files while performing image conversions.
177 | * If set to null, storage_path('media-library/temp') will be used.
178 | */
179 | 'temporary_directory_path' => null,
180 |
181 | /*
182 | * The engine that should perform the image conversions.
183 | * Should be either `gd` or `imagick`.
184 | */
185 | 'image_driver' => env('IMAGE_DRIVER', 'gd'),
186 |
187 | /*
188 | * FFMPEG & FFProbe binaries paths, only used if you try to generate video
189 | * thumbnails and have installed the php-ffmpeg/php-ffmpeg composer
190 | * dependency.
191 | */
192 | 'ffmpeg_path' => env('FFMPEG_PATH', '/usr/bin/ffmpeg'),
193 | 'ffprobe_path' => env('FFPROBE_PATH', '/usr/bin/ffprobe'),
194 |
195 | /*
196 | * Here you can override the class names of the jobs used by this package. Make sure
197 | * your custom jobs extend the ones provided by the package.
198 | */
199 | 'jobs' => [
200 | 'perform_conversions' => Spatie\MediaLibrary\Conversions\Jobs\PerformConversionsJob::class,
201 | 'generate_responsive_images' => Spatie\MediaLibrary\ResponsiveImages\Jobs\GenerateResponsiveImagesJob::class,
202 | ],
203 |
204 | /*
205 | * When using the addMediaFromUrl method you may want to replace the default downloader.
206 | * This is particularly useful when the url of the image is behind a firewall and
207 | * need to add additional flags, possibly using curl.
208 | */
209 | 'media_downloader' => Spatie\MediaLibrary\Downloaders\DefaultDownloader::class,
210 |
211 | /*
212 | * When using the addMediaFromUrl method the SSL is verified by default.
213 | * This is option disables SSL verification when downloading remote media.
214 | * Please note that this is a security risk and should only be false in a local environment.
215 | */
216 | 'media_downloader_ssl' => env('MEDIA_DOWNLOADER_SSL', true),
217 |
218 | 'remote' => [
219 | /*
220 | * Any extra headers that should be included when uploading media to
221 | * a remote disk. Even though supported headers may vary between
222 | * different drivers, a sensible default has been provided.
223 | *
224 | * Supported by S3: CacheControl, Expires, StorageClass,
225 | * ServerSideEncryption, Metadata, ACL, ContentEncoding
226 | */
227 | 'extra_headers' => [
228 | 'CacheControl' => 'max-age=604800',
229 | ],
230 | ],
231 |
232 | 'responsive_images' => [
233 | /*
234 | * This class is responsible for calculating the target widths of the responsive
235 | * images. By default we optimize for filesize and create variations that each are 30%
236 | * smaller than the previous one. More info in the documentation.
237 | *
238 | * https://docs.spatie.be/laravel-medialibrary/v9/advanced-usage/generating-responsive-images
239 | */
240 | 'width_calculator' => Spatie\MediaLibrary\ResponsiveImages\WidthCalculator\FileSizeOptimizedWidthCalculator::class,
241 |
242 | /*
243 | * By default rendering media to a responsive image will add some javascript and a tiny placeholder.
244 | * This ensures that the browser can already determine the correct layout.
245 | * When disabled, no tiny placeholder is generated.
246 | */
247 | 'use_tiny_placeholders' => true,
248 |
249 | /*
250 | * This class will generate the tiny placeholder used for progressive image loading. By default
251 | * the media library will use a tiny blurred jpg image.
252 | */
253 | 'tiny_placeholder_generator' => Spatie\MediaLibrary\ResponsiveImages\TinyPlaceholderGenerator\Blurred::class,
254 | ],
255 |
256 | /*
257 | * When enabling this option, a route will be registered that will enable
258 | * the Media Library Pro Vue and React components to move uploaded files
259 | * in a S3 bucket to their right place.
260 | */
261 | 'enable_vapor_uploads' => env('ENABLE_MEDIA_LIBRARY_VAPOR_UPLOADS', false),
262 |
263 | /*
264 | * When converting Media instances to response the media library will add
265 | * a `loading` attribute to the `img` tag. Here you can set the default
266 | * value of that attribute.
267 | *
268 | * Possible values: 'lazy', 'eager', 'auto' or null if you don't want to set any loading instruction.
269 | *
270 | * More info: https://css-tricks.com/native-lazy-loading/
271 | */
272 | 'default_loading_attribute_value' => null,
273 |
274 | /*
275 | * You can specify a prefix for that is used for storing all media.
276 | * If you set this to `/my-subdir`, all your media will be stored in a `/my-subdir` directory.
277 | */
278 | 'prefix' => env('MEDIA_PREFIX', ''),
279 |
280 | /*
281 | * When forcing lazy loading, media will be loaded even if you don't eager load media and you have
282 | * disabled lazy loading globally in the service provider.
283 | */
284 | 'force_lazy_loading' => env('FORCE_MEDIA_LIBRARY_LAZY_LOADING', true),
285 | ];
286 |
--------------------------------------------------------------------------------
/database/migrations/create_media_table.php.stub:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | use Illuminate\Database\Migrations\Migration;
4 | use Illuminate\Database\Schema\Blueprint;
5 | use Illuminate\Support\Facades\Schema;
6 |
7 | return new class extends Migration
8 | {
9 | public function up(): void
10 | {
11 | Schema::create('media', function (Blueprint $table) {
12 | $table->id();
13 |
14 | $table->morphs('model');
15 | $table->uuid()->nullable()->unique();
16 | $table->string('collection_name');
17 | $table->string('name');
18 | $table->string('file_name');
19 | $table->string('mime_type')->nullable();
20 | $table->string('disk');
21 | $table->string('conversions_disk')->nullable();
22 | $table->unsignedBigInteger('size');
23 | $table->json('manipulations');
24 | $table->json('custom_properties');
25 | $table->json('generated_conversions');
26 | $table->json('responsive_images');
27 | $table->unsignedInteger('order_column')->nullable()->index();
28 |
29 | $table->nullableTimestamps();
30 | });
31 | }
32 | };
33 |
--------------------------------------------------------------------------------
/resources/views/image.blade.php:
--------------------------------------------------------------------------------
1 | <img{!! $attributeString !!}@if($loadingAttributeValue) loading="{{ $loadingAttributeValue }}"@endif src="{{ $media->getUrl($conversion) }}" alt="{{ $media->name }}">
--------------------------------------------------------------------------------
/resources/views/placeholderSvg.blade.php:
--------------------------------------------------------------------------------
1 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
2 | <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" x="0"
3 | y="0" viewBox="0 0 {{ $originalImageWidth }} {{ $originalImageHeight }}">
4 | <image width="{{ $originalImageWidth }}" height="{{ $originalImageHeight }}" xlink:href="{{ $tinyImageBase64 }}">
5 | </image>
6 | </svg>
--------------------------------------------------------------------------------
/resources/views/responsiveImage.blade.php:
--------------------------------------------------------------------------------
1 | <img{!! $attributeString !!}@if($loadingAttributeValue) loading="{{ $loadingAttributeValue }}"@endif srcset="{{ $media->getSrcset($conversion) }}" src="{{ $media->getUrl($conversion) }}" width="{{ $width }}" height="{{ $height }}" alt="{{ $media->name }}">
--------------------------------------------------------------------------------
/resources/views/responsiveImageWithPlaceholder.blade.php:
--------------------------------------------------------------------------------
1 | <img{!! $attributeString !!} @if($loadingAttributeValue) loading="{{ $loadingAttributeValue }}"@endif srcset="{{ $media->getSrcset($conversion) }}" onload="window.requestAnimationFrame(function(){if(!(size=getBoundingClientRect().width))return;onload=null;sizes=Math.ceil(size/window.innerWidth*100)+'vw';});" sizes="1px" src="{{ $media->getUrl($conversion) }}" width="{{ $width }}" height="{{ $height }}" alt="{{ $media->name }}">
2 |
--------------------------------------------------------------------------------
/src/Conversions/Actions/PerformConversionAction.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Actions;
4 |
5 | use Spatie\MediaLibrary\Conversions\Conversion;
6 | use Spatie\MediaLibrary\Conversions\Events\ConversionHasBeenCompletedEvent;
7 | use Spatie\MediaLibrary\Conversions\Events\ConversionWillStartEvent;
8 | use Spatie\MediaLibrary\Conversions\ImageGenerators\ImageGeneratorFactory;
9 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
10 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
11 | use Spatie\MediaLibrary\ResponsiveImages\ResponsiveImageGenerator;
12 |
13 | class PerformConversionAction
14 | {
15 | public function execute(
16 | Conversion $conversion,
17 | Media $media,
18 | string $copiedOriginalFile
19 | ): void {
20 | $imageGenerator = ImageGeneratorFactory::forMedia($media);
21 |
22 | $copiedOriginalFile = $imageGenerator->convert($copiedOriginalFile, $conversion);
23 |
24 | if (! $copiedOriginalFile) {
25 | return;
26 | }
27 |
28 | event(new ConversionWillStartEvent($media, $conversion, $copiedOriginalFile));
29 |
30 | $manipulationResult = (new PerformManipulationsAction)->execute($media, $conversion, $copiedOriginalFile);
31 |
32 | $newFileName = $conversion->getConversionFile($media);
33 |
34 | $renamedFile = $this->renameInLocalDirectory($manipulationResult, $newFileName);
35 |
36 | if ($conversion->shouldGenerateResponsiveImages()) {
37 | /** @var ResponsiveImageGenerator $responsiveImageGenerator */
38 | $responsiveImageGenerator = app(ResponsiveImageGenerator::class);
39 |
40 | $responsiveImageGenerator->generateResponsiveImagesForConversion(
41 | $media,
42 | $conversion,
43 | $renamedFile
44 | );
45 | }
46 |
47 | app(Filesystem::class)->copyToMediaLibrary($renamedFile, $media, 'conversions');
48 |
49 | $media->markAsConversionGenerated($conversion->getName());
50 |
51 | event(new ConversionHasBeenCompletedEvent($media, $conversion));
52 | }
53 |
54 | protected function renameInLocalDirectory(
55 | string $fileNameWithDirectory,
56 | string $newFileNameWithoutDirectory
57 | ): string {
58 | $targetFile = pathinfo($fileNameWithDirectory, PATHINFO_DIRNAME).'/'.$newFileNameWithoutDirectory;
59 |
60 | rename($fileNameWithDirectory, $targetFile);
61 |
62 | return $targetFile;
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/Conversions/Actions/PerformManipulationsAction.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Actions;
4 |
5 | use Illuminate\Support\Facades\File;
6 | use Illuminate\Support\Str;
7 | use Spatie\Image\Exceptions\UnsupportedImageFormat;
8 | use Spatie\Image\Image;
9 | use Spatie\MediaLibrary\Conversions\Conversion;
10 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
11 |
12 | class PerformManipulationsAction
13 | {
14 | public function execute(
15 | Media $media,
16 | Conversion $conversion,
17 | string $imageFile,
18 | ): string {
19 |
20 | if ($conversion->getManipulations()->isEmpty()) {
21 | return $imageFile;
22 | }
23 |
24 | $conversionTempFile = $this->getConversionTempFileName($media, $conversion, $imageFile);
25 |
26 | File::copy($imageFile, $conversionTempFile);
27 |
28 | $supportedFormats = ['jpg', 'jpeg', 'pjpg', 'png', 'gif', 'webp'];
29 | if ($conversion->shouldKeepOriginalImageFormat() && in_array($media->extension, $supportedFormats)) {
30 | $conversion->format($media->extension);
31 | }
32 |
33 | $image = Image::useImageDriver(config('media-library.image_driver'))
34 | ->loadFile($conversionTempFile)
35 | ->format('jpg');
36 |
37 | try {
38 | $conversion->getManipulations()->apply($image);
39 |
40 | $image->save();
41 | } catch (UnsupportedImageFormat) {
42 |
43 | }
44 |
45 | return $conversionTempFile;
46 | }
47 |
48 | protected function getConversionTempFileName(
49 | Media $media,
50 | Conversion $conversion,
51 | string $imageFile,
52 | ): string {
53 | $directory = pathinfo($imageFile, PATHINFO_DIRNAME);
54 |
55 | $extension = $media->extension;
56 |
57 | if ($extension === '') {
58 | $extension = 'jpg';
59 | }
60 |
61 | $fileName = Str::random(32)."{$conversion->getName()}.{$extension}";
62 |
63 | return "{$directory}/{$fileName}";
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/src/Conversions/Commands/RegenerateCommand.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Commands;
4 |
5 | use Exception;
6 | use Illuminate\Console\Command;
7 | use Illuminate\Console\ConfirmableTrait;
8 | use Illuminate\Support\Arr;
9 | use Illuminate\Support\LazyCollection;
10 | use Illuminate\Support\Str;
11 | use Spatie\MediaLibrary\Conversions\FileManipulator;
12 | use Spatie\MediaLibrary\MediaCollections\MediaRepository;
13 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
14 |
15 | class RegenerateCommand extends Command
16 | {
17 | use ConfirmableTrait;
18 |
19 | protected $signature = 'media-library:regenerate {modelType?} {--ids=*}
20 | {--only=* : Regenerate specific conversions}
21 | {--starting-from-id= : Regenerate media with an id equal to or higher than the provided value}
22 | {--X|exclude-starting-id : Exclude the provided id when regenerating from a specific id}
23 | {--only-missing : Regenerate only missing conversions}
24 | {--with-responsive-images : Regenerate responsive images}
25 | {--force : Force the operation to run when in production}
26 | {--queue-all : Queue all conversions, even non-queued ones}';
27 |
28 | protected $description = 'Regenerate the derived images of media';
29 |
30 | protected MediaRepository $mediaRepository;
31 |
32 | protected FileManipulator $fileManipulator;
33 |
34 | protected array $errorMessages = [];
35 |
36 | public function handle(MediaRepository $mediaRepository, FileManipulator $fileManipulator): void
37 | {
38 | $this->mediaRepository = $mediaRepository;
39 |
40 | $this->fileManipulator = $fileManipulator;
41 |
42 | if (! $this->confirmToProceed()) {
43 | return;
44 | }
45 |
46 | $mediaFiles = $this->getMediaToBeRegenerated();
47 |
48 | $progressBar = $this->output->createProgressBar($mediaFiles->count());
49 |
50 | if (config('media-library.queue_connection_name') === 'sync') {
51 | set_time_limit(0);
52 | }
53 |
54 | $mediaFiles->each(function (Media $media) use ($progressBar) {
55 | try {
56 | $this->fileManipulator->createDerivedFiles(
57 | $media,
58 | Arr::wrap($this->option('only')),
59 | $this->option('only-missing'),
60 | $this->option('with-responsive-images'),
61 | $this->option('queue-all'),
62 | );
63 | } catch (Exception $exception) {
64 | $this->errorMessages[$media->getKey()] = $exception->getMessage();
65 | }
66 |
67 | $progressBar->advance();
68 | });
69 |
70 | $progressBar->finish();
71 |
72 | if (count($this->errorMessages)) {
73 | $this->warn('All done, but with some error messages:');
74 |
75 | foreach ($this->errorMessages as $mediaId => $message) {
76 | $this->warn("Media id {$mediaId}: `{$message}`");
77 | }
78 | }
79 |
80 | $this->newLine(2);
81 |
82 | $this->info('All done!');
83 | }
84 |
85 | public function getMediaToBeRegenerated(): LazyCollection
86 | {
87 | // Get this arg first as it can also be passed to the greater-than-id branch
88 | $modelType = $this->argument('modelType');
89 |
90 | $startingFromId = (int) $this->option('starting-from-id');
91 | if ($startingFromId !== 0) {
92 | $excludeStartingId = (bool) $this->option('exclude-starting-id') ?: false;
93 |
94 | return $this->mediaRepository->getByIdGreaterThan($startingFromId, $excludeStartingId, is_string($modelType) ? $modelType : '');
95 | }
96 |
97 | if (is_string($modelType)) {
98 | return $this->mediaRepository->getByModelType($modelType);
99 | }
100 |
101 | $mediaIds = $this->getMediaIds();
102 | if (count($mediaIds) > 0) {
103 | return $this->mediaRepository->getByIds($mediaIds);
104 | }
105 |
106 | return $this->mediaRepository->all();
107 | }
108 |
109 | protected function getMediaIds(): array
110 | {
111 | $mediaIds = $this->option('ids');
112 |
113 | if (! is_array($mediaIds)) {
114 | $mediaIds = explode(',', (string) $mediaIds);
115 | }
116 |
117 | if (count($mediaIds) === 1 && Str::contains((string) $mediaIds[0], ',')) {
118 | $mediaIds = explode(',', (string) $mediaIds[0]);
119 | }
120 |
121 | return $mediaIds;
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/src/Conversions/Conversion.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions;
4 |
5 | use Illuminate\Support\Arr;
6 | use Illuminate\Support\Traits\Conditionable;
7 | use Spatie\ImageOptimizer\OptimizerChainFactory;
8 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
9 | use Spatie\MediaLibrary\ResponsiveImages\WidthCalculator\WidthCalculator;
10 | use Spatie\MediaLibrary\Support\FileNamer\FileNamer;
11 |
12 | /** @mixin \Spatie\Image\Drivers\ImageDriver */
13 | class Conversion
14 | {
15 | use Conditionable;
16 |
17 | protected FileNamer $fileNamer;
18 |
19 | protected float $extractVideoFrameAtSecond = 0;
20 |
21 | protected Manipulations $manipulations;
22 |
23 | protected array $performOnCollections = [];
24 |
25 | protected bool $performOnQueue;
26 |
27 | protected bool $keepOriginalImageFormat = false;
28 |
29 | protected bool $generateResponsiveImages = false;
30 |
31 | protected ?WidthCalculator $widthCalculator = null;
32 |
33 | protected ?string $loadingAttributeValue;
34 |
35 | protected int $pdfPageNumber = 1;
36 |
37 | public function __construct(
38 | protected string $name,
39 | ) {
40 | $optimizerChain = OptimizerChainFactory::create(config('media-library.image_optimizers'));
41 |
42 | $this->manipulations = new Manipulations;
43 | $this->manipulations->optimize($optimizerChain)->format('jpg');
44 |
45 | $this->fileNamer = app(config('media-library.file_namer'));
46 |
47 | $this->loadingAttributeValue = config('media-library.default_loading_attribute_value');
48 |
49 | $this->performOnQueue = config('media-library.queue_conversions_by_default', true);
50 | }
51 |
52 | public static function create(string $name): self
53 | {
54 | return new static($name);
55 | }
56 |
57 | public function getName(): string
58 | {
59 | return $this->name;
60 | }
61 |
62 | public function getPerformOnCollections(): array
63 | {
64 | if (! count($this->performOnCollections)) {
65 | return ['default'];
66 | }
67 |
68 | return $this->performOnCollections;
69 | }
70 |
71 | public function extractVideoFrameAtSecond(float $timeCode): self
72 | {
73 | $this->extractVideoFrameAtSecond = $timeCode;
74 |
75 | return $this;
76 | }
77 |
78 | public function getExtractVideoFrameAtSecond(): float
79 | {
80 | return $this->extractVideoFrameAtSecond;
81 | }
82 |
83 | public function keepOriginalImageFormat(): self
84 | {
85 | $this->keepOriginalImageFormat = true;
86 |
87 | return $this;
88 | }
89 |
90 | public function shouldKeepOriginalImageFormat(): bool
91 | {
92 | return $this->keepOriginalImageFormat;
93 | }
94 |
95 | public function getManipulations(): Manipulations
96 | {
97 | return $this->manipulations;
98 | }
99 |
100 | public function removeManipulation(string $manipulationName): self
101 | {
102 | $this->manipulations->removeManipulation($manipulationName);
103 |
104 | return $this;
105 | }
106 |
107 | public function withoutManipulations(): self
108 | {
109 | $this->manipulations = new Manipulations;
110 |
111 | return $this;
112 | }
113 |
114 | public function __call($name, $arguments): self
115 | {
116 | $this->manipulations->$name(...$arguments);
117 |
118 | return $this;
119 | }
120 |
121 | public function setManipulations($manipulations): self
122 | {
123 | if ($manipulations instanceof Manipulations) {
124 | $this->manipulations = $this->manipulations->mergeManipulations($manipulations);
125 | }
126 |
127 | if (is_callable($manipulations)) {
128 | $manipulations($this->manipulations);
129 | }
130 |
131 | return $this;
132 | }
133 |
134 | public function addAsFirstManipulations(Manipulations $manipulations): self
135 | {
136 | $newManipulations = $manipulations->toArray();
137 |
138 | $currentManipulations = $this->manipulations->toArray();
139 |
140 | $allManipulations = array_merge($newManipulations, Arr::except($currentManipulations, array_keys($newManipulations)));
141 |
142 | $this->manipulations = new Manipulations($allManipulations);
143 |
144 | return $this;
145 | }
146 |
147 | public function performOnCollections(...$collectionNames): self
148 | {
149 | $this->performOnCollections = $collectionNames;
150 |
151 | return $this;
152 | }
153 |
154 | public function shouldBePerformedOn(string $collectionName): bool
155 | {
156 | // if no collections were specified, perform conversion on all collections
157 | if (! count($this->performOnCollections)) {
158 | return true;
159 | }
160 |
161 | if (in_array('*', $this->performOnCollections)) {
162 | return true;
163 | }
164 |
165 | return in_array($collectionName, $this->performOnCollections);
166 | }
167 |
168 | public function queued(): self
169 | {
170 | $this->performOnQueue = true;
171 |
172 | return $this;
173 | }
174 |
175 | public function nonQueued(): self
176 | {
177 | $this->performOnQueue = false;
178 |
179 | return $this;
180 | }
181 |
182 | public function nonOptimized(): self
183 | {
184 | $this->removeManipulation('optimize');
185 |
186 | return $this;
187 | }
188 |
189 | public function withResponsiveImages(bool $withResponsiveImages = true): self
190 | {
191 | $this->generateResponsiveImages = $withResponsiveImages;
192 |
193 | return $this;
194 | }
195 |
196 | public function withWidthCalculator(WidthCalculator $widthCalculator): self
197 | {
198 | $this->widthCalculator = $widthCalculator;
199 |
200 | return $this;
201 | }
202 |
203 | public function getWidthCalculator(): ?WidthCalculator
204 | {
205 | return $this->widthCalculator;
206 | }
207 |
208 | public function shouldGenerateResponsiveImages(): bool
209 | {
210 | return $this->generateResponsiveImages;
211 | }
212 |
213 | public function shouldBeQueued(): bool
214 | {
215 | return $this->performOnQueue;
216 | }
217 |
218 | public function getResultExtension(string $originalFileExtension = ''): string
219 | {
220 | if ($this->shouldKeepOriginalImageFormat()) {
221 | if (in_array(strtolower($originalFileExtension), ['jpg', 'jpeg', 'pjpg', 'png', 'gif', 'webp', 'avif'])) {
222 | return $originalFileExtension;
223 | }
224 | }
225 |
226 | if ($manipulationArgument = Arr::get($this->manipulations->getManipulationArgument('format'), 0)) {
227 | return $manipulationArgument;
228 | }
229 |
230 | return $originalFileExtension;
231 | }
232 |
233 | public function getConversionFile(Media $media): string
234 | {
235 | $fileName = $this->fileNamer->conversionFileName($media->file_name, $this);
236 |
237 | $fileExtension = $this->fileNamer->extensionFromBaseImage($media->file_name);
238 | $extension = $this->getResultExtension($fileExtension) ?: $fileExtension;
239 |
240 | return "{$fileName}.{$extension}";
241 | }
242 |
243 | public function useLoadingAttributeValue(string $value): self
244 | {
245 | $this->loadingAttributeValue = $value;
246 |
247 | return $this;
248 | }
249 |
250 | public function getLoadingAttributeValue(): ?string
251 | {
252 | return $this->loadingAttributeValue;
253 | }
254 |
255 | public function pdfPageNumber(int $pageNumber): self
256 | {
257 | $this->pdfPageNumber = $pageNumber;
258 |
259 | return $this;
260 | }
261 |
262 | public function getPdfPageNumber(): int
263 | {
264 | return $this->pdfPageNumber;
265 | }
266 | }
267 |
--------------------------------------------------------------------------------
/src/Conversions/ConversionCollection.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions;
4 |
5 | use Illuminate\Database\Eloquent\Relations\Relation;
6 | use Illuminate\Support\Arr;
7 | use Illuminate\Support\Collection;
8 | use Spatie\MediaLibrary\MediaCollections\Exceptions\InvalidConversion;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 |
11 | /**
12 | * @template TKey of array-key
13 | * @template TValue of Conversion
14 | *
15 | * @extends Collection<TKey, TValue>
16 | */
17 | class ConversionCollection extends Collection
18 | {
19 | protected Media $media;
20 |
21 | public static function createForMedia(Media $media): self
22 | {
23 | return (new static)->setMedia($media);
24 | }
25 |
26 | /**
27 | * @return $this
28 | */
29 | public function setMedia(Media $media): self
30 | {
31 | $this->media = $media;
32 |
33 | $this->items = [];
34 |
35 | $this->addConversionsFromRelatedModel($media);
36 |
37 | $this->addManipulationsFromDb($media);
38 |
39 | return $this;
40 | }
41 |
42 | public function getByName(string $name): Conversion
43 | {
44 | $conversion = $this->first(fn (Conversion $conversion) => $conversion->getName() === $name);
45 |
46 | if (! $conversion) {
47 | throw InvalidConversion::unknownName($name);
48 | }
49 |
50 | return $conversion;
51 | }
52 |
53 | protected function addConversionsFromRelatedModel(Media $media): void
54 | {
55 | $modelName = Arr::get(Relation::morphMap(), $media->model_type, $media->model_type);
56 |
57 | if (! class_exists($modelName)) {
58 | return;
59 | }
60 |
61 | /** @var \Spatie\MediaLibrary\HasMedia $model */
62 | $model = new $modelName;
63 |
64 | /*
65 | * In some cases the user might want to get the actual model
66 | * instance so conversion parameters can depend on model
67 | * properties. This will causes extra queries.
68 | */
69 | if ($model->registerMediaConversionsUsingModelInstance && $media->model) {
70 | $model = $media->model;
71 |
72 | $model->mediaConversions = [];
73 | }
74 |
75 | $model->registerAllMediaConversions($media);
76 |
77 | $this->items = $model->mediaConversions;
78 | }
79 |
80 | protected function addManipulationsFromDb(Media $media): void
81 | {
82 | collect(Arr::except($media->manipulations, '*'))->each(function ($manipulation, $conversionName) {
83 | $manipulations = new Manipulations($manipulation);
84 |
85 | $this->addManipulationToConversion($manipulations, $conversionName);
86 | });
87 |
88 | if (array_key_exists('*', $media->manipulations)) {
89 | $globalManipulations = new Manipulations($media->manipulations['*']);
90 |
91 | $this->addManipulationToConversion($globalManipulations, '*');
92 | }
93 | }
94 |
95 | public function getConversions(string $collectionName = ''): self
96 | {
97 | if ($collectionName === '') {
98 | return $this;
99 | }
100 |
101 | return $this->filter(fn (Conversion $conversion) => $conversion->shouldBePerformedOn($collectionName));
102 | }
103 |
104 | protected function addManipulationToConversion(Manipulations $manipulations, string $conversionName): void
105 | {
106 | /** @var Conversion|null $conversion */
107 | $conversion = $this->first(function (Conversion $conversion) use ($conversionName) {
108 | if (! $conversion->shouldBePerformedOn($this->media->collection_name)) {
109 | return false;
110 | }
111 |
112 | if ($conversion->getName() !== $conversionName) {
113 | return false;
114 | }
115 |
116 | return true;
117 | });
118 |
119 | if ($conversion) {
120 | $conversion->addAsFirstManipulations($manipulations);
121 | }
122 |
123 | if ($conversionName === '*') {
124 | $this->each(
125 | fn (Conversion $conversion) => $conversion->addAsFirstManipulations(clone $manipulations)
126 | );
127 | }
128 | }
129 |
130 | public function getConversionsFiles(string $collectionName = ''): self
131 | {
132 | return $this
133 | ->getConversions($collectionName)
134 | ->map(fn (Conversion $conversion) => $conversion->getConversionFile($this->media));
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/src/Conversions/Events/ConversionHasBeenCompletedEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Events;
4 |
5 | use Illuminate\Queue\SerializesModels;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | class ConversionHasBeenCompletedEvent
10 | {
11 | use SerializesModels;
12 |
13 | public function __construct(public Media $media, public Conversion $conversion) {}
14 | }
15 |
--------------------------------------------------------------------------------
/src/Conversions/Events/ConversionWillStartEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Events;
4 |
5 | use Illuminate\Queue\SerializesModels;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | class ConversionWillStartEvent
10 | {
11 | use SerializesModels;
12 |
13 | public function __construct(
14 | public Media $media,
15 | public Conversion $conversion,
16 | public string $copiedOriginalFile,
17 | ) {}
18 | }
19 |
--------------------------------------------------------------------------------
/src/Conversions/FileManipulator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions;
4 |
5 | use Illuminate\Support\Facades\Storage;
6 | use Illuminate\Support\Str;
7 | use Spatie\MediaLibrary\Conversions\Actions\PerformConversionAction;
8 | use Spatie\MediaLibrary\Conversions\ImageGenerators\ImageGeneratorFactory;
9 | use Spatie\MediaLibrary\Conversions\Jobs\PerformConversionsJob;
10 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
11 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
12 | use Spatie\MediaLibrary\ResponsiveImages\Jobs\GenerateResponsiveImagesJob;
13 | use Spatie\MediaLibrary\Support\TemporaryDirectory;
14 |
15 | class FileManipulator
16 | {
17 | public function createDerivedFiles(
18 | Media $media,
19 | array $onlyConversionNames = [],
20 | bool $onlyMissing = false,
21 | bool $withResponsiveImages = false,
22 | bool $queueAll = false,
23 | ): void {
24 | if (! $this->canConvertMedia($media)) {
25 | return;
26 | }
27 |
28 | [$queuedConversions, $conversions] = ConversionCollection::createForMedia($media)
29 | ->filter(function (Conversion $conversion) use ($onlyConversionNames) {
30 | if (count($onlyConversionNames) === 0) {
31 | return true;
32 | }
33 |
34 | return in_array($conversion->getName(), $onlyConversionNames);
35 | })
36 | ->filter(fn (Conversion $conversion) => $conversion->shouldBePerformedOn($media->collection_name))
37 | ->partition(fn (Conversion $conversion) => $queueAll || $conversion->shouldBeQueued());
38 |
39 | $this
40 | ->performConversions($conversions, $media, $onlyMissing)
41 | ->dispatchQueuedConversions($media, $queuedConversions, $onlyMissing)
42 | ->generateResponsiveImages($media, $withResponsiveImages);
43 | }
44 |
45 | public function performConversions(
46 | ConversionCollection $conversions,
47 | Media $media,
48 | bool $onlyMissing = false
49 | ): self {
50 | $conversions = $conversions
51 | ->when(
52 | $onlyMissing,
53 | fn (ConversionCollection $conversions) => $conversions->reject(function (Conversion $conversion) use ($media) {
54 | $relativePath = $media->getPath($conversion->getName());
55 |
56 | if ($rootPath = config("filesystems.disks.{$media->disk}.root")) {
57 | $relativePath = str_replace($rootPath, '', $relativePath);
58 | }
59 |
60 | return Storage::disk($media->disk)->exists($relativePath);
61 | })
62 | );
63 |
64 | if ($conversions->isEmpty()) {
65 | return $this;
66 | }
67 |
68 | $temporaryDirectory = TemporaryDirectory::create();
69 |
70 | $copiedOriginalFile = app(Filesystem::class)->copyFromMediaLibrary(
71 | $media,
72 | $temporaryDirectory->path(Str::random(32).'.'.$media->extension)
73 | );
74 |
75 | $conversions->each(fn (Conversion $conversion) => (new PerformConversionAction)->execute($conversion, $media, $copiedOriginalFile));
76 |
77 | $temporaryDirectory->delete();
78 |
79 | return $this;
80 | }
81 |
82 | /**
83 | * @return $this
84 | */
85 | protected function dispatchQueuedConversions(
86 | Media $media,
87 | ConversionCollection $conversions,
88 | bool $onlyMissing = false
89 | ): self {
90 | if ($conversions->isEmpty()) {
91 | return $this;
92 | }
93 |
94 | $performConversionsJobClass = config(
95 | 'media-library.jobs.perform_conversions',
96 | PerformConversionsJob::class
97 | );
98 |
99 | /** @var PerformConversionsJob $job */
100 | $job = (new $performConversionsJobClass($conversions, $media, $onlyMissing))
101 | ->onConnection(config('media-library.queue_connection_name'))
102 | ->onQueue(config('media-library.queue_name'));
103 |
104 | config('media-library.queue_conversions_after_database_commit')
105 | ? dispatch($job)->afterCommit()
106 | : dispatch($job);
107 |
108 | return $this;
109 | }
110 |
111 | /**
112 | * @return $this
113 | */
114 | protected function generateResponsiveImages(Media $media, bool $withResponsiveImages): self
115 | {
116 | if (! $withResponsiveImages) {
117 | return $this;
118 | }
119 |
120 | if (! count($media->responsive_images)) {
121 | return $this;
122 | }
123 |
124 | $generateResponsiveImagesJobClass = config(
125 | 'media-library.jobs.generate_responsive_images',
126 | GenerateResponsiveImagesJob::class
127 | );
128 |
129 | /** @var GenerateResponsiveImagesJob $job */
130 | $job = (new $generateResponsiveImagesJobClass($media))
131 | ->onConnection(config('media-library.queue_connection_name'))
132 | ->onQueue(config('media-library.queue_name'));
133 |
134 | config('media-library.queue_conversions_after_database_commit')
135 | ? dispatch($job)->afterCommit()
136 | : dispatch($job);
137 |
138 | return $this;
139 | }
140 |
141 | protected function canConvertMedia(Media $media): bool
142 | {
143 | $imageGenerator = ImageGeneratorFactory::forMedia($media);
144 |
145 | return $imageGenerator ? true : false;
146 | }
147 | }
148 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Avif.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 |
8 | class Avif extends ImageGenerator
9 | {
10 | public function convert(string $file, ?Conversion $conversion = null): string
11 | {
12 | $pathToImageFile = pathinfo($file, PATHINFO_DIRNAME).'/'.pathinfo($file, PATHINFO_FILENAME).'.png';
13 |
14 | $image = imagecreatefromavif($file);
15 |
16 | imagepng($image, $pathToImageFile, 9);
17 |
18 | imagedestroy($image);
19 |
20 | return $pathToImageFile;
21 | }
22 |
23 | public function requirementsAreInstalled(): bool
24 | {
25 | if (! function_exists('imagecreatefromavif')) {
26 | return false;
27 | }
28 |
29 | if (! function_exists('imagepng')) {
30 | return false;
31 | }
32 |
33 | if (! function_exists('imagedestroy')) {
34 | return false;
35 | }
36 |
37 | return true;
38 | }
39 |
40 | public function supportedExtensions(): Collection
41 | {
42 | return collect(['avif']);
43 | }
44 |
45 | public function supportedMimeTypes(): Collection
46 | {
47 | return collect(['image/avif']);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Image.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 |
8 | class Image extends ImageGenerator
9 | {
10 | public function convert(string $path, ?Conversion $conversion = null): string
11 | {
12 | return $path;
13 | }
14 |
15 | public function requirementsAreInstalled(): bool
16 | {
17 | return true;
18 | }
19 |
20 | public function supportedExtensions(): Collection
21 | {
22 | $extensions = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'avif'];
23 | if (config('media-library.image_driver') === 'imagick') {
24 | $extensions[] = 'tiff';
25 | $extensions[] = 'heic';
26 | $extensions[] = 'heif';
27 | }
28 |
29 | return collect($extensions);
30 | }
31 |
32 | public function supportedMimeTypes(): Collection
33 | {
34 | $mimeTypes = ['image/jpeg', 'image/gif', 'image/png', 'image/webp', 'image/avif'];
35 | if (config('media-library.image_driver') === 'imagick') {
36 | $mimeTypes[] = 'image/tiff';
37 | $mimeTypes[] = 'image/heic';
38 | $mimeTypes[] = 'image/heif';
39 | }
40 |
41 | return collect($mimeTypes);
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/ImageGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | abstract class ImageGenerator
10 | {
11 | /*
12 | * This function should return a path to an image representation of the given file.
13 | */
14 | abstract public function convert(string $file, ?Conversion $conversion = null): ?string;
15 |
16 | public function canConvert(Media $media): bool
17 | {
18 | if (! $this->requirementsAreInstalled()) {
19 | return false;
20 | }
21 |
22 | $validExtension = $this->canHandleExtension(strtolower($media->extension));
23 |
24 | $validMimeType = $this->canHandleMime(strtolower($media->mime_type));
25 |
26 | if ($this->shouldMatchBothExtensionsAndMimeTypes()) {
27 | return $validExtension && $validMimeType;
28 | }
29 |
30 | return $validExtension || $validMimeType;
31 | }
32 |
33 | public function shouldMatchBothExtensionsAndMimeTypes(): bool
34 | {
35 | return false;
36 | }
37 |
38 | public function canHandleMime(string $mime = ''): bool
39 | {
40 | return $this->supportedMimeTypes()->contains($mime);
41 | }
42 |
43 | public function canHandleExtension(string $extension = ''): bool
44 | {
45 | return $this->supportedExtensions()->contains($extension);
46 | }
47 |
48 | public function getType(): string
49 | {
50 | return strtolower(class_basename(static::class));
51 | }
52 |
53 | abstract public function requirementsAreInstalled(): bool;
54 |
55 | abstract public function supportedExtensions(): Collection;
56 |
57 | abstract public function supportedMimeTypes(): Collection;
58 | }
59 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/ImageGeneratorFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class ImageGeneratorFactory
9 | {
10 | public static function getImageGenerators(): Collection
11 | {
12 | return collect(config('media-library.image_generators'))
13 | ->map(function ($imageGeneratorClassName, $key) {
14 | $imageGeneratorConfig = [];
15 |
16 | if (! is_numeric($key)) {
17 | $imageGeneratorConfig = $imageGeneratorClassName;
18 | $imageGeneratorClassName = $key;
19 | }
20 |
21 | return app($imageGeneratorClassName, $imageGeneratorConfig);
22 | });
23 | }
24 |
25 | public static function forExtension(?string $extension): ?ImageGenerator
26 | {
27 | if (is_null($extension)) {
28 | return null;
29 | }
30 |
31 | return static::getImageGenerators()
32 | ->first(fn (ImageGenerator $imageGenerator) => $imageGenerator->canHandleExtension(strtolower($extension)));
33 | }
34 |
35 | public static function forMimeType(?string $mimeType): ?ImageGenerator
36 | {
37 | if (is_null($mimeType)) {
38 | return null;
39 | }
40 |
41 | return static::getImageGenerators()
42 | ->first(fn (ImageGenerator $imageGenerator) => $imageGenerator->canHandleMime($mimeType));
43 | }
44 |
45 | public static function forMedia(Media $media): ?ImageGenerator
46 | {
47 | return static::getImageGenerators()
48 | ->first(fn (ImageGenerator $imageGenerator) => $imageGenerator->canConvert($media));
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Pdf.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Composer\InstalledVersions;
6 | use Composer\Semver\VersionParser;
7 | use Illuminate\Support\Collection;
8 | use Imagick;
9 | use Spatie\MediaLibrary\Conversions\Conversion;
10 |
11 | class Pdf extends ImageGenerator
12 | {
13 | public function convert(string $file, ?Conversion $conversion = null): string
14 | {
15 | $imageFile = pathinfo($file, PATHINFO_DIRNAME).'/'.pathinfo($file, PATHINFO_FILENAME).'.jpg';
16 |
17 | $pageNumber = $conversion ? $conversion->getPdfPageNumber() : 1;
18 |
19 | if ($this->usesPdfToImageV3()) {
20 | (new \Spatie\PdfToImage\Pdf($file))->selectPage($pageNumber)->save($imageFile);
21 | } else {
22 | (new \Spatie\PdfToImage\Pdf($file))->setPage($pageNumber)->saveImage($imageFile);
23 | }
24 |
25 | return $imageFile;
26 | }
27 |
28 | private function usesPdfToImageV3(): bool
29 | {
30 | return InstalledVersions::satisfies(new VersionParser, 'spatie/pdf-to-image', '^3.0');
31 | }
32 |
33 | public function requirementsAreInstalled(): bool
34 | {
35 | if (! class_exists(Imagick::class)) {
36 | return false;
37 | }
38 |
39 | if (! class_exists(\Spatie\PdfToImage\Pdf::class)) {
40 | return false;
41 | }
42 |
43 | return true;
44 | }
45 |
46 | public function supportedExtensions(): Collection
47 | {
48 | return collect(['pdf']);
49 | }
50 |
51 | public function supportedMimeTypes(): Collection
52 | {
53 | return collect(['application/pdf']);
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Svg.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Imagick;
7 | use ImagickPixel;
8 | use Spatie\MediaLibrary\Conversions\Conversion;
9 |
10 | class Svg extends ImageGenerator
11 | {
12 | public function convert(string $file, ?Conversion $conversion = null): string
13 | {
14 | $imageFile = pathinfo($file, PATHINFO_DIRNAME).'/'.pathinfo($file, PATHINFO_FILENAME).'.png';
15 |
16 | $image = new Imagick;
17 | $image->setBackgroundColor(new ImagickPixel('none'));
18 | $image->readImage($file);
19 |
20 | $image->setImageFormat('png32');
21 |
22 | file_put_contents($imageFile, $image);
23 |
24 | return $imageFile;
25 | }
26 |
27 | public function requirementsAreInstalled(): bool
28 | {
29 | return class_exists(Imagick::class);
30 | }
31 |
32 | public function supportedExtensions(): Collection
33 | {
34 | return collect(['svg']);
35 | }
36 |
37 | public function supportedMimeTypes(): Collection
38 | {
39 | return collect(['image/svg+xml']);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Video.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use FFMpeg\Coordinate\TimeCode;
6 | use FFMpeg\FFMpeg;
7 | use FFMpeg\Media\Video as FFMpegVideo;
8 | use Illuminate\Support\Collection;
9 | use Spatie\MediaLibrary\Conversions\Conversion;
10 |
11 | class Video extends ImageGenerator
12 | {
13 | public function convert(string $file, ?Conversion $conversion = null): ?string
14 | {
15 | $ffmpeg = FFMpeg::create([
16 | 'ffmpeg.binaries' => config('media-library.ffmpeg_path'),
17 | 'ffprobe.binaries' => config('media-library.ffprobe_path'),
18 | ]);
19 |
20 | $video = $ffmpeg->open($file);
21 |
22 | if (! ($video instanceof FFMpegVideo)) {
23 | return null;
24 | }
25 |
26 | $duration = $ffmpeg->getFFProbe()->format($file)->get('duration');
27 |
28 | $seconds = $conversion ? $conversion->getExtractVideoFrameAtSecond() : 0;
29 | $seconds = $duration <= $seconds ? 0 : $seconds;
30 |
31 | $imageFile = pathinfo($file, PATHINFO_DIRNAME).'/'.pathinfo($file, PATHINFO_FILENAME).'.jpg';
32 |
33 | $frame = $video->frame(TimeCode::fromSeconds($seconds));
34 | $frame->save($imageFile);
35 |
36 | return $imageFile;
37 | }
38 |
39 | public function requirementsAreInstalled(): bool
40 | {
41 | return class_exists('\\FFMpeg\\FFMpeg');
42 | }
43 |
44 | public function supportedExtensions(): Collection
45 | {
46 | return collect(['webm', 'mov', 'mp4']);
47 | }
48 |
49 | public function supportedMimeTypes(): Collection
50 | {
51 | return collect(['video/webm', 'video/mpeg', 'video/mp4', 'video/quicktime']);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/Conversions/ImageGenerators/Webp.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\ImageGenerators;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 |
8 | class Webp extends ImageGenerator
9 | {
10 | public function convert(string $file, ?Conversion $conversion = null): string
11 | {
12 | $pathToImageFile = pathinfo($file, PATHINFO_DIRNAME).'/'.pathinfo($file, PATHINFO_FILENAME).'.png';
13 |
14 | $image = imagecreatefromwebp($file);
15 |
16 | imagepng($image, $pathToImageFile, 9);
17 |
18 | imagedestroy($image);
19 |
20 | return $pathToImageFile;
21 | }
22 |
23 | public function requirementsAreInstalled(): bool
24 | {
25 | if (! function_exists('imagecreatefromwebp')) {
26 | return false;
27 | }
28 |
29 | if (! function_exists('imagepng')) {
30 | return false;
31 | }
32 |
33 | if (! function_exists('imagedestroy')) {
34 | return false;
35 | }
36 |
37 | return true;
38 | }
39 |
40 | public function supportedExtensions(): Collection
41 | {
42 | return collect(['webp']);
43 | }
44 |
45 | public function supportedMimeTypes(): Collection
46 | {
47 | return collect(['image/webp']);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/Conversions/Jobs/PerformConversionsJob.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions\Jobs;
4 |
5 | use Illuminate\Bus\Queueable;
6 | use Illuminate\Contracts\Queue\ShouldQueue;
7 | use Illuminate\Queue\InteractsWithQueue;
8 | use Illuminate\Queue\SerializesModels;
9 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
10 | use Spatie\MediaLibrary\Conversions\FileManipulator;
11 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
12 |
13 | class PerformConversionsJob implements ShouldQueue
14 | {
15 | use InteractsWithQueue;
16 | use Queueable;
17 | use SerializesModels;
18 |
19 | public $deleteWhenMissingModels = true;
20 |
21 | public function __construct(
22 | protected ConversionCollection $conversions,
23 | protected Media $media,
24 | protected bool $onlyMissing = false,
25 | ) {}
26 |
27 | public function handle(FileManipulator $fileManipulator): bool
28 | {
29 | $fileManipulator->performConversions(
30 | $this->conversions,
31 | $this->media,
32 | $this->onlyMissing
33 | );
34 |
35 | return true;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/Conversions/Manipulations.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Conversions;
4 |
5 | use Spatie\Image\Drivers\ImageDriver;
6 | use Spatie\Image\Enums\AlignPosition;
7 | use Spatie\Image\Enums\BorderType;
8 | use Spatie\Image\Enums\Constraint;
9 | use Spatie\Image\Enums\CropPosition;
10 | use Spatie\Image\Enums\Fit;
11 | use Spatie\Image\Enums\FlipDirection;
12 | use Spatie\Image\Enums\Orientation;
13 |
14 | /** @mixin \Spatie\Image\Drivers\ImageDriver */
15 | class Manipulations
16 | {
17 | protected array $manipulations = [];
18 |
19 | public function __construct(array $manipulations = [])
20 | {
21 | $this->manipulations = $manipulations;
22 | }
23 |
24 | public function __call(string $method, array $parameters): self
25 | {
26 | $this->addManipulation($method, $parameters);
27 |
28 | return $this;
29 | }
30 |
31 | /**
32 | * @return $this
33 | */
34 | public function addManipulation(string $name, array $parameters = []): self
35 | {
36 | $this->manipulations[$name] = $parameters;
37 |
38 | return $this;
39 | }
40 |
41 | public function getManipulationArgument(string $manipulationName): null|string|array
42 | {
43 | return $this->manipulations[$manipulationName] ?? null;
44 | }
45 |
46 | public function getFirstManipulationArgument(string $manipulationName): null|string|int
47 | {
48 | $manipulationArgument = $this->getManipulationArgument($manipulationName);
49 |
50 | if (! is_array($manipulationArgument)) {
51 | return null;
52 | }
53 |
54 | return $manipulationArgument[0];
55 | }
56 |
57 | public function isEmpty(): bool
58 | {
59 | return count($this->manipulations) === 0;
60 | }
61 |
62 | public function apply(ImageDriver $image): void
63 | {
64 | foreach ($this->manipulations as $manipulationName => $parameters) {
65 | $parameters = $this->transformParameters($manipulationName, $parameters);
66 | $image->$manipulationName(...$parameters);
67 | }
68 | }
69 |
70 | /**
71 | * @return $this
72 | */
73 | public function mergeManipulations(self $manipulations): self
74 | {
75 | foreach ($manipulations->toArray() as $name => $parameters) {
76 | $this->manipulations[$name] = array_merge($this->manipulations[$name] ?? [], $parameters ?: []);
77 | }
78 |
79 | return $this;
80 | }
81 |
82 | /**
83 | * @return $this
84 | */
85 | public function removeManipulation(string $name): self
86 | {
87 | unset($this->manipulations[$name]);
88 |
89 | return $this;
90 | }
91 |
92 | public function toArray(): array
93 | {
94 | return $this->manipulations;
95 | }
96 |
97 | public function transformParameters(int|string $manipulationName, mixed $parameters): mixed
98 | {
99 | switch ($manipulationName) {
100 | case 'border':
101 | if (isset($parameters['type']) && ! $parameters['type'] instanceof BorderType) {
102 | $parameters['type'] = BorderType::from($parameters['type']);
103 | }
104 | break;
105 | case 'watermark':
106 | if (isset($parameters['fit']) && ! $parameters['fit'] instanceof Fit) {
107 | $parameters['fit'] = Fit::from($parameters['fit']);
108 | }
109 | // Fallthrough intended for position
110 | case 'resizeCanvas':
111 | case 'insert':
112 | if (isset($parameters['position']) && ! $parameters['position'] instanceof AlignPosition) {
113 | $parameters['position'] = AlignPosition::from($parameters['position']);
114 | }
115 | break;
116 | case 'resize':
117 | case 'width':
118 | case 'height':
119 | if (isset($parameters['constraints']) && is_array($parameters['constraints'])) {
120 | foreach ($parameters['constraints'] as &$constraint) {
121 | if (! $constraint instanceof Constraint) {
122 | $constraint = Constraint::from($constraint);
123 | }
124 | }
125 | }
126 | break;
127 | case 'crop':
128 | if (isset($parameters['position']) && ! $parameters['position'] instanceof CropPosition) {
129 | $parameters['position'] = CropPosition::from($parameters['position']);
130 | }
131 | break;
132 | case 'fit':
133 | if (isset($parameters['fit']) && ! $parameters['fit'] instanceof Fit) {
134 | $parameters['fit'] = Fit::from($parameters['fit']);
135 | }
136 | break;
137 | case 'flip':
138 | if (isset($parameters['flip']) && ! $parameters['flip'] instanceof FlipDirection) {
139 | $parameters['flip'] = FlipDirection::from($parameters['flip']);
140 | }
141 | break;
142 | case 'orientation':
143 | if (isset($parameters['orientation']) && ! $parameters['orientation'] instanceof Orientation) {
144 | $parameters['orientation'] = Orientation::from($parameters['orientation']);
145 | }
146 | break;
147 | default:
148 | break;
149 | }
150 |
151 | return $parameters;
152 | }
153 | }
154 |
--------------------------------------------------------------------------------
/src/Downloaders/DefaultDownloader.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Downloaders;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Exceptions\UnreachableUrl;
6 |
7 | class DefaultDownloader implements Downloader
8 | {
9 | public function getTempFile(string $url): string
10 | {
11 | $context = stream_context_create([
12 | 'ssl' => [
13 | 'verify_peer' => config('media-library.media_downloader_ssl'),
14 | 'verify_peer_name' => config('media-library.media_downloader_ssl'),
15 | ],
16 | 'http' => [
17 | 'header' => 'User-Agent: Spatie MediaLibrary',
18 | ],
19 | ]);
20 |
21 | if (! $stream = @fopen($url, 'r', false, $context)) {
22 | throw UnreachableUrl::create($url);
23 | }
24 |
25 | $temporaryFile = tempnam(sys_get_temp_dir(), 'media-library');
26 |
27 | file_put_contents($temporaryFile, $stream);
28 |
29 | fclose($stream);
30 |
31 | return $temporaryFile;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/Downloaders/Downloader.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Downloaders;
4 |
5 | interface Downloader
6 | {
7 | public function getTempFile(string $url): string;
8 | }
9 |
--------------------------------------------------------------------------------
/src/Downloaders/HttpFacadeDownloader.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Downloaders;
4 |
5 | use Illuminate\Support\Facades\Http;
6 | use Spatie\MediaLibrary\MediaCollections\Exceptions\UnreachableUrl;
7 |
8 | class HttpFacadeDownloader implements Downloader
9 | {
10 | public function getTempFile(string $url): string
11 | {
12 | $temporaryFile = tempnam(sys_get_temp_dir(), 'media-library');
13 |
14 | Http::withUserAgent('Spatie MediaLibrary')
15 | ->throw(fn () => throw new UnreachableUrl($url))
16 | ->sink($temporaryFile)
17 | ->get($url);
18 |
19 | return $temporaryFile;
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/Enums/CollectionPosition.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Enums;
4 |
5 | enum CollectionPosition: string
6 | {
7 | case First = 'first';
8 | case Last = 'last';
9 | }
10 |
--------------------------------------------------------------------------------
/src/HasMedia.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary;
4 |
5 | use Illuminate\Database\Eloquent\Relations\MorphMany;
6 | use Illuminate\Support\Collection;
7 | use Spatie\MediaLibrary\Conversions\Conversion;
8 | use Spatie\MediaLibrary\MediaCollections\FileAdder;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 | use Symfony\Component\HttpFoundation\File\UploadedFile;
11 |
12 | /**
13 | * @mixin \Illuminate\Database\Eloquent\Model
14 | *
15 | * @method void prepareToAttachMedia(Media $media, FileAdder $fileAdder)
16 | *
17 | * @property bool $registerMediaConversionsUsingModelInstance
18 | * @property ?\Spatie\MediaLibrary\MediaCollections\MediaCollection $mediaCollections
19 | */
20 | interface HasMedia
21 | {
22 | public function media(): MorphMany;
23 |
24 | public function addMedia(string|UploadedFile $file): FileAdder;
25 |
26 | public function copyMedia(string|UploadedFile $file): FileAdder;
27 |
28 | public function hasMedia(string $collectionName = ''): bool;
29 |
30 | public function getMedia(string $collectionName = 'default', array|callable $filters = []): Collection;
31 |
32 | public function clearMediaCollection(string $collectionName = 'default'): HasMedia;
33 |
34 | public function clearMediaCollectionExcept(string $collectionName = 'default', array|Collection $excludedMedia = []): HasMedia;
35 |
36 | public function shouldDeletePreservingMedia(): bool;
37 |
38 | public function loadMedia(string $collectionName);
39 |
40 | public function addMediaConversion(string $name): Conversion;
41 |
42 | public function registerMediaConversions(?Media $media = null): void;
43 |
44 | public function registerMediaCollections(): void;
45 |
46 | public function registerAllMediaConversions(): void;
47 |
48 | public function getMediaModel(): string;
49 | }
50 |
--------------------------------------------------------------------------------
/src/MediaCollections/Commands/CleanCommand.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Commands;
4 |
5 | use Illuminate\Console\Command;
6 | use Illuminate\Console\ConfirmableTrait;
7 | use Illuminate\Contracts\Filesystem\Factory;
8 | use Illuminate\Support\LazyCollection;
9 | use Illuminate\Support\Str;
10 | use Spatie\MediaLibrary\Conversions\Conversion;
11 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
12 | use Spatie\MediaLibrary\Conversions\FileManipulator;
13 | use Spatie\MediaLibrary\MediaCollections\Exceptions\DiskDoesNotExist;
14 | use Spatie\MediaLibrary\MediaCollections\MediaRepository;
15 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
16 | use Spatie\MediaLibrary\ResponsiveImages\RegisteredResponsiveImages;
17 | use Spatie\MediaLibrary\Support\PathGenerator\PathGeneratorFactory;
18 |
19 | class CleanCommand extends Command
20 | {
21 | use ConfirmableTrait;
22 |
23 | protected $signature = 'media-library:clean {modelType?} {collectionName?} {disk?}
24 | {--dry-run : List files that will be removed without removing them},
25 | {--force : Force the operation to run when in production},
26 | {--rate-limit= : Limit the number of requests per second},
27 | {--delete-orphaned : Delete orphaned media items},
28 | {--skip-conversions : Do not remove deprecated conversions}';
29 |
30 | protected $description = 'Clean deprecated conversions and files without related model.';
31 |
32 | protected MediaRepository $mediaRepository;
33 |
34 | protected FileManipulator $fileManipulator;
35 |
36 | protected Factory $fileSystem;
37 |
38 | protected bool $isDryRun = false;
39 |
40 | protected int $rateLimit = 0;
41 |
42 | public function handle(
43 | MediaRepository $mediaRepository,
44 | FileManipulator $fileManipulator,
45 | Factory $fileSystem,
46 | ): void {
47 | $this->mediaRepository = $mediaRepository;
48 | $this->fileManipulator = $fileManipulator;
49 | $this->fileSystem = $fileSystem;
50 |
51 | if (! $this->confirmToProceed()) {
52 | return;
53 | }
54 |
55 | $this->isDryRun = $this->option('dry-run');
56 | $this->rateLimit = (int) $this->option('rate-limit');
57 |
58 | if ($this->option('delete-orphaned')) {
59 | $this->deleteOrphanedMediaItems();
60 | }
61 |
62 | if (! $this->option('skip-conversions')) {
63 | $this->deleteFilesGeneratedForDeprecatedConversions();
64 | }
65 |
66 | $this->deleteOrphanedDirectories();
67 |
68 | $this->info('All done!');
69 | }
70 |
71 | /** @return LazyCollection<int, Media> */
72 | public function getMediaItems(): LazyCollection
73 | {
74 | $modelType = $this->argument('modelType');
75 | $collectionName = $this->argument('collectionName');
76 |
77 | if (is_string($modelType) && is_string($collectionName)) {
78 | return $this->mediaRepository->getByModelTypeAndCollectionName(
79 | $modelType,
80 | $collectionName
81 | );
82 | }
83 |
84 | if (is_string($modelType)) {
85 | return $this->mediaRepository->getByModelType($modelType);
86 | }
87 |
88 | if (is_string($collectionName)) {
89 | return $this->mediaRepository->getByCollectionName($collectionName);
90 | }
91 |
92 | return $this->mediaRepository->all();
93 | }
94 |
95 | protected function deleteOrphanedMediaItems(): void
96 | {
97 | $this->getOrphanedMediaItems()->each(function (Media $media): void {
98 | if ($this->isDryRun) {
99 | $this->info("Orphaned Media[id={$media->id}] found");
100 |
101 | return;
102 | }
103 |
104 | $media->delete();
105 |
106 | if ($this->rateLimit) {
107 | usleep((1 / $this->rateLimit) * 1_000_000);
108 | }
109 |
110 | $this->info("Orphaned Media[id={$media->id}] has been removed");
111 | });
112 | }
113 |
114 | /** @return LazyCollection<int, Media> */
115 | protected function getOrphanedMediaItems(): LazyCollection
116 | {
117 | $collectionName = $this->argument('collectionName');
118 |
119 | if (is_string($collectionName)) {
120 | return $this->mediaRepository->getOrphansByCollectionName($collectionName);
121 | }
122 |
123 | return $this->mediaRepository->getOrphans();
124 | }
125 |
126 | protected function deleteFilesGeneratedForDeprecatedConversions(): void
127 | {
128 | $this->getMediaItems()->each(function (Media $media) {
129 | $this->deleteConversionFilesForDeprecatedConversions($media);
130 |
131 | if ($media->responsive_images) {
132 | $this->deleteDeprecatedResponsiveImages($media);
133 | }
134 |
135 | if ($this->rateLimit) {
136 | usleep((1 / $this->rateLimit) * 1_000_000 * 2);
137 | }
138 | });
139 | }
140 |
141 | protected function deleteConversionFilesForDeprecatedConversions(Media $media): void
142 | {
143 | $conversionFilePaths = ConversionCollection::createForMedia($media)->getConversionsFiles($media->collection_name);
144 |
145 | $conversionPath = PathGeneratorFactory::create($media)->getPathForConversions($media);
146 | $currentFilePaths = $this->fileSystem->disk($media->disk)->files($conversionPath);
147 |
148 | collect($currentFilePaths)
149 | ->reject(fn (string $currentFilePath) => $conversionFilePaths->contains(basename($currentFilePath)))
150 | ->reject(fn (string $currentFilePath) => $media->file_name === basename($currentFilePath))
151 | ->each(function (string $currentFilePath) use ($media) {
152 | if (! $this->isDryRun) {
153 | $this->fileSystem->disk($media->disk)->delete($currentFilePath);
154 |
155 | $this->markConversionAsRemoved($media, $currentFilePath);
156 | }
157 |
158 | $this->info("Deprecated conversion file `{$currentFilePath}` ".($this->isDryRun ? 'found' : 'has been removed'));
159 | });
160 | }
161 |
162 | protected function deleteDeprecatedResponsiveImages(Media $media): void
163 | {
164 | $conversionNamesWithResponsiveImages = ConversionCollection::createForMedia($media)
165 | ->filter(fn (Conversion $conversion) => $conversion->shouldGenerateResponsiveImages())
166 | ->map(fn (Conversion $conversion) => $conversion->getName())
167 | ->push('media_library_original');
168 |
169 | /** @var array<int, string> $responsiveImagesGeneratedFor */
170 | $responsiveImagesGeneratedFor = array_keys($media->responsive_images);
171 |
172 | collect($responsiveImagesGeneratedFor)
173 | ->map(fn (string $generatedFor) => $media->responsiveImages($generatedFor))
174 | ->reject(fn (RegisteredResponsiveImages $responsiveImages) => $conversionNamesWithResponsiveImages->contains($responsiveImages->generatedFor))
175 | ->each(function (RegisteredResponsiveImages $responsiveImages) {
176 | if (! $this->isDryRun) {
177 | $responsiveImages->delete();
178 | }
179 | });
180 | }
181 |
182 | protected function deleteOrphanedDirectories(): void
183 | {
184 | $diskName = $this->argument('disk') ?: config('media-library.disk_name');
185 |
186 | if (is_null(config("filesystems.disks.{$diskName}"))) {
187 | throw DiskDoesNotExist::create($diskName);
188 | }
189 |
190 | $prefix = config('media-library.prefix', '');
191 |
192 | if ($prefix !== '') {
193 | $prefix = trim($prefix, '/').'/';
194 | }
195 |
196 | $mediaIds = $this->mediaRepository->allIds();
197 |
198 | /** @var array<int, string> */
199 | $directories = $this->fileSystem->disk($diskName)->directories($prefix);
200 |
201 | collect($directories)
202 | ->map(fn (string $directory) => str_replace($prefix, '', $directory))
203 | ->filter(fn (string $directory) => is_numeric($directory))
204 | ->reject(fn (string $directory) => $mediaIds->contains((int) $directory))
205 | ->each(function (string $directory) use ($diskName, $prefix) {
206 | $directory = $prefix.$directory;
207 |
208 | if (! $this->isDryRun) {
209 | $this->fileSystem->disk($diskName)->deleteDirectory($directory);
210 | }
211 |
212 | if ($this->rateLimit) {
213 | usleep((1 / $this->rateLimit) * 1_000_000);
214 | }
215 |
216 | $this->info("Orphaned media directory `{$directory}` ".($this->isDryRun ? 'found' : 'has been removed'));
217 | });
218 | }
219 |
220 | protected function markConversionAsRemoved(Media $media, string $conversionPath): void
221 | {
222 | $conversionFile = pathinfo($conversionPath, PATHINFO_FILENAME);
223 |
224 | $generatedConversionName = null;
225 |
226 | $media->getGeneratedConversions()
227 | ->dot()
228 | ->filter(
229 | fn (bool $isGenerated, string $generatedConversionName) => Str::contains($conversionFile, $generatedConversionName)
230 | )
231 | ->each(
232 | fn (bool $isGenerated, string $conversionName) => $media->markAsConversionNotGenerated($conversionName)
233 | );
234 |
235 | $media->save();
236 | }
237 | }
238 |
--------------------------------------------------------------------------------
/src/MediaCollections/Commands/ClearCommand.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Commands;
4 |
5 | use Illuminate\Console\Command;
6 | use Illuminate\Console\ConfirmableTrait;
7 | use Illuminate\Support\LazyCollection;
8 | use Spatie\MediaLibrary\MediaCollections\MediaRepository;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 |
11 | class ClearCommand extends Command
12 | {
13 | use ConfirmableTrait;
14 |
15 | protected $signature = 'media-library:clear {modelType?} {collectionName?}
16 | {-- force : Force the operation to run when in production}';
17 |
18 | protected $description = 'Delete all items in a media collection.';
19 |
20 | protected MediaRepository $mediaRepository;
21 |
22 | public function handle(MediaRepository $mediaRepository): void
23 | {
24 | $this->mediaRepository = $mediaRepository;
25 |
26 | if (! $this->confirmToProceed()) {
27 | return;
28 | }
29 |
30 | $mediaItems = $this->getMediaItems();
31 |
32 | $progressBar = $this->output->createProgressBar($mediaItems->count());
33 |
34 | $mediaItems->each(function (Media $media) use ($progressBar) {
35 | $media->delete();
36 | $progressBar->advance();
37 | });
38 |
39 | $progressBar->finish();
40 |
41 | $this->info('All done!');
42 | }
43 |
44 | /** @return LazyCollection<int, Media> */
45 | public function getMediaItems(): LazyCollection
46 | {
47 | $modelType = $this->argument('modelType');
48 | $collectionName = $this->argument('collectionName');
49 |
50 | if (is_string($modelType) && is_string($collectionName)) {
51 | return $this->mediaRepository->getByModelTypeAndCollectionName(
52 | $modelType,
53 | $collectionName
54 | );
55 | }
56 |
57 | if (is_string($modelType)) {
58 | return $this->mediaRepository->getByModelType($modelType);
59 | }
60 |
61 | if (is_string($collectionName)) {
62 | return $this->mediaRepository->getByCollectionName($collectionName);
63 | }
64 |
65 | return $this->mediaRepository->all();
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/src/MediaCollections/Contracts/MediaLibraryRequest.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Contracts;
4 |
5 | use Illuminate\Support\Collection;
6 |
7 | interface MediaLibraryRequest
8 | {
9 | public function mediaLibraryRequestItems(string $key): Collection;
10 | }
11 |
--------------------------------------------------------------------------------
/src/MediaCollections/Events/CollectionHasBeenClearedEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Events;
4 |
5 | use Illuminate\Queue\SerializesModels;
6 | use Spatie\MediaLibrary\HasMedia;
7 |
8 | class CollectionHasBeenClearedEvent
9 | {
10 | use SerializesModels;
11 |
12 | public function __construct(public HasMedia $model, public string $collectionName) {}
13 | }
14 |
--------------------------------------------------------------------------------
/src/MediaCollections/Events/MediaHasBeenAddedEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Events;
4 |
5 | use Illuminate\Queue\SerializesModels;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class MediaHasBeenAddedEvent
9 | {
10 | use SerializesModels;
11 |
12 | public function __construct(public Media $media) {}
13 | }
14 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/DiskCannotBeAccessed.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class DiskCannotBeAccessed extends FileCannotBeAdded
6 | {
7 | public static function create(string $diskName): self
8 | {
9 | return new static("Disk named `{$diskName}` cannot be accessed");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/DiskDoesNotExist.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class DiskDoesNotExist extends FileCannotBeAdded
6 | {
7 | public static function create(string $diskName): self
8 | {
9 | return new static("There is no filesystem disk named `{$diskName}`");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FileCannotBeAdded.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 |
7 | abstract class FileCannotBeAdded extends Exception {}
8 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FileDoesNotExist.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class FileDoesNotExist extends FileCannotBeAdded
6 | {
7 | public static function create(string $path): self
8 | {
9 | return new static("File `{$path}` does not exist");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FileIsTooBig.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Spatie\MediaLibrary\Support\File;
6 |
7 | class FileIsTooBig extends FileCannotBeAdded
8 | {
9 | public static function create(string $path, ?int $size = null): self
10 | {
11 | $fileSize = File::getHumanReadableSize($size ?: filesize($path));
12 |
13 | $maxFileSize = File::getHumanReadableSize(config('media-library.max_file_size'));
14 |
15 | return new static("File `{$path}` has a size of {$fileSize} which is greater than the maximum allowed {$maxFileSize}");
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FileNameNotAllowed.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class FileNameNotAllowed extends FileCannotBeAdded
6 | {
7 | public static function create(string $orignalName, string $sanitizedName): self
8 | {
9 | return new static("The file name `{$orignalName}` was sanitized to `{$sanitizedName}`. This sanitized file name is not allowed because it is a PHP file.");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FileUnacceptableForCollection.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Spatie\MediaLibrary\HasMedia;
6 | use Spatie\MediaLibrary\MediaCollections\File;
7 | use Spatie\MediaLibrary\MediaCollections\MediaCollection;
8 |
9 | class FileUnacceptableForCollection extends FileCannotBeAdded
10 | {
11 | public static function create(File $file, MediaCollection $mediaCollection, HasMedia $hasMedia): self
12 | {
13 | $modelType = $hasMedia::class;
14 |
15 | return new static("The file with properties `{$file}` was not accepted into the collection named `{$mediaCollection->name}` of model `{$modelType}` with id `{$hasMedia->getKey()}`");
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/FunctionalityNotAvailable.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 |
7 | class FunctionalityNotAvailable extends Exception
8 | {
9 | public static function mediaLibraryProRequired(): self
10 | {
11 | return new static('You need to have media library pro installed to make this work.');
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidBase64Data.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class InvalidBase64Data extends FileCannotBeAdded
6 | {
7 | public static function create(): self
8 | {
9 | return new static('Invalid base64 data provided');
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidConversion.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 |
7 | class InvalidConversion extends Exception
8 | {
9 | public static function unknownName(string $name): self
10 | {
11 | return new static("There is no conversion named `{$name}`");
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidFileRemover.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 | use Spatie\MediaLibrary\Support\FileRemover\FileRemover;
7 |
8 | class InvalidFileRemover extends Exception
9 | {
10 | public static function doesntExist(string $class): self
11 | {
12 | return new static("File remover class `{$class}` doesn't exist");
13 | }
14 |
15 | public static function doesNotImplementFileRemover(string $class): self
16 | {
17 | $fileRemoverClass = FileRemover::class;
18 |
19 | return new static("File remover class `{$class}` must implement `$fileRemoverClass}`");
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidPathGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 | use Spatie\MediaLibrary\Support\PathGenerator\PathGenerator;
7 |
8 | class InvalidPathGenerator extends Exception
9 | {
10 | public static function doesntExist(string $class): self
11 | {
12 | return new static("Path generator class `{$class}` doesn't exist");
13 | }
14 |
15 | public static function doesNotImplementPathGenerator(string $class): self
16 | {
17 | $pathGeneratorClass = PathGenerator::class;
18 |
19 | return new static("Path generator class `{$class}` must implement `$pathGeneratorClass}`");
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidUrl.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 |
7 | class InvalidUrl extends Exception
8 | {
9 | public static function doesNotStartWithProtocol(string $url): self
10 | {
11 | return new static("Could not add `{$url}` because it does not start with either `http://` or `https://`");
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/InvalidUrlGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 | use Spatie\MediaLibrary\Support\UrlGenerator\UrlGenerator;
7 |
8 | class InvalidUrlGenerator extends Exception
9 | {
10 | public static function doesntExist(string $class): self
11 | {
12 | return new static("Url generator class {$class} doesn't exist");
13 | }
14 |
15 | public static function doesNotImplementUrlGenerator(string $class): self
16 | {
17 | $urlGeneratorClass = UrlGenerator::class;
18 |
19 | return new static("Url generator Class {$class} must implement `{$urlGeneratorClass}`");
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/MediaCannotBeDeleted.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 | use Illuminate\Database\Eloquent\Model;
7 |
8 | class MediaCannotBeDeleted extends Exception
9 | {
10 | public static function doesNotBelongToModel($mediaId, Model $model): self
11 | {
12 | $modelClass = $model::class;
13 |
14 | return new static("Media with id `{$mediaId}` cannot be deleted because it does not exist or does not belong to model {$modelClass} with id {$model->getKey()}");
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/MediaCannotBeUpdated.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | use Exception;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class MediaCannotBeUpdated extends Exception
9 | {
10 | public static function doesNotBelongToCollection(string $collectionName, Media $media): self
11 | {
12 | return new static("Media id {$media->getKey()} is not part of collection `{$collectionName}`");
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/MimeTypeNotAllowed.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class MimeTypeNotAllowed extends FileCannotBeAdded
6 | {
7 | public static function create(string $file, array $allowedMimeTypes): self
8 | {
9 | $mimeType = mime_content_type($file);
10 |
11 | $allowedMimeTypes = implode(', ', $allowedMimeTypes);
12 |
13 | return new static("File has a mime type of {$mimeType}, while only {$allowedMimeTypes} are allowed");
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/RequestDoesNotHaveFile.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class RequestDoesNotHaveFile extends FileCannotBeAdded
6 | {
7 | public static function create(string $key): self
8 | {
9 | return new static("The current request does not have a file in a key named `{$key}`");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/UnknownType.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class UnknownType extends FileCannotBeAdded
6 | {
7 | public static function create(): self
8 | {
9 | return new static('Only strings, FileObjects and UploadedFileObjects can be imported');
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/Exceptions/UnreachableUrl.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Exceptions;
4 |
5 | class UnreachableUrl extends FileCannotBeAdded
6 | {
7 | public static function create(string $url): self
8 | {
9 | return new static("Url `{$url}` cannot be reached");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/MediaCollections/File.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | class File implements \Stringable
6 | {
7 | public static function createFromMedia($media): self
8 | {
9 | return new static($media->file_name, $media->size, $media->mime_type);
10 | }
11 |
12 | public function __construct(
13 | public string $name,
14 | public int $size,
15 | public string $mimeType
16 | ) {}
17 |
18 | public function __toString(): string
19 | {
20 | return "name: {$this->name}, size: {$this->size}, mime: {$this->mimeType}";
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/MediaCollections/FileAdderFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | use Illuminate\Database\Eloquent\Model;
6 | use Illuminate\Support\Collection;
7 | use Spatie\MediaLibrary\MediaCollections\Exceptions\RequestDoesNotHaveFile;
8 | use Spatie\MediaLibrary\Support\RemoteFile;
9 | use Spatie\MediaLibraryPro\Dto\PendingMediaItem;
10 | use Symfony\Component\HttpFoundation\File\UploadedFile;
11 |
12 | class FileAdderFactory
13 | {
14 | public static function create(Model $subject, string|UploadedFile $file): FileAdder
15 | {
16 | /** @var FileAdder $fileAdder */
17 | $fileAdder = app(FileAdder::class);
18 |
19 | return $fileAdder
20 | ->setSubject($subject)
21 | ->setFile($file);
22 | }
23 |
24 | public static function createFromDisk(Model $subject, string $key, string $disk): FileAdder
25 | {
26 | /** @var FileAdder $fileAdder */
27 | $fileAdder = app(FileAdder::class);
28 |
29 | return $fileAdder
30 | ->setSubject($subject)
31 | ->setFile(new RemoteFile($key, $disk));
32 | }
33 |
34 | public static function createFromRequest(Model $subject, string $key): FileAdder
35 | {
36 | return static::createMultipleFromRequest($subject, [$key])->first();
37 | }
38 |
39 | public static function createMultipleFromRequest(Model $subject, array $keys = []): Collection
40 | {
41 | return collect($keys)
42 | ->map(function (string $key) use ($subject) {
43 | $key = trim(basename($key), './');
44 |
45 | if (! request()->hasFile($key)) {
46 | throw RequestDoesNotHaveFile::create($key);
47 | }
48 |
49 | $files = request()->file($key);
50 |
51 | if (! is_array($files)) {
52 | return static::create($subject, $files);
53 | }
54 |
55 | return array_map(fn ($file) => static::create($subject, $file), $files);
56 | })->flatten();
57 | }
58 |
59 | public static function createAllFromRequest(Model $subject): Collection
60 | {
61 | $fileKeys = array_keys(request()->allFiles());
62 |
63 | return static::createMultipleFromRequest($subject, $fileKeys);
64 | }
65 |
66 | public static function createForPendingMedia(Model $subject, PendingMediaItem $pendingMedia): FileAdder
67 | {
68 | /** @var FileAdder $fileAdder */
69 | $fileAdder = app(FileAdder::class);
70 |
71 | return $fileAdder
72 | ->setSubject($subject)
73 | ->setFile($pendingMedia->temporaryUpload)
74 | ->setName($pendingMedia->name)
75 | ->setOrder($pendingMedia->order);
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/src/MediaCollections/Filesystem.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | use Illuminate\Contracts\Filesystem\Factory;
6 | use Illuminate\Support\Facades\Storage;
7 | use Illuminate\Support\Str;
8 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
9 | use Spatie\MediaLibrary\Conversions\FileManipulator;
10 | use Spatie\MediaLibrary\MediaCollections\Events\MediaHasBeenAddedEvent;
11 | use Spatie\MediaLibrary\MediaCollections\Exceptions\DiskCannotBeAccessed;
12 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
13 | use Spatie\MediaLibrary\Support\File;
14 | use Spatie\MediaLibrary\Support\FileNamer\FileNamer;
15 | use Spatie\MediaLibrary\Support\FileRemover\FileRemoverFactory;
16 | use Spatie\MediaLibrary\Support\PathGenerator\PathGeneratorFactory;
17 | use Spatie\MediaLibrary\Support\RemoteFile;
18 |
19 | class Filesystem
20 | {
21 | protected array $customRemoteHeaders = [];
22 |
23 | public function __construct(
24 | protected Factory $filesystem
25 | ) {}
26 |
27 | public function add(string $file, Media $media, ?string $targetFileName = null): bool
28 | {
29 | try {
30 | $this->copyToMediaLibrary($file, $media, null, $targetFileName);
31 | } catch (DiskCannotBeAccessed $exception) {
32 | return false;
33 | }
34 |
35 | event(new MediaHasBeenAddedEvent($media));
36 |
37 | app(FileManipulator::class)->createDerivedFiles($media);
38 |
39 | return true;
40 | }
41 |
42 | public function addRemote(RemoteFile $file, Media $media, ?string $targetFileName = null): bool
43 | {
44 | try {
45 | $this->copyToMediaLibraryFromRemote($file, $media, null, $targetFileName);
46 | } catch (DiskCannotBeAccessed $exception) {
47 | return false;
48 | }
49 |
50 | event(new MediaHasBeenAddedEvent($media));
51 |
52 | app(FileManipulator::class)->createDerivedFiles($media);
53 |
54 | return true;
55 | }
56 |
57 | public function prepareCopyFileOnDisk(RemoteFile $file, Media $media, string $destination): void
58 | {
59 | $this->copyFileOnDisk($file->getKey(), $destination, $media->disk);
60 | }
61 |
62 | public function copyToMediaLibraryFromRemote(RemoteFile $file, Media $media, ?string $type = null, ?string $targetFileName = null): void
63 | {
64 | $destinationFileName = $targetFileName ?: $file->getFilename();
65 |
66 | $destination = $this->getMediaDirectory($media, $type).$destinationFileName;
67 |
68 | $diskDriverName = (in_array($type, ['conversions', 'responsiveImages']))
69 | ? $media->getConversionsDiskDriverName()
70 | : $media->getDiskDriverName();
71 |
72 | if ($this->shouldCopyFileOnDisk($file, $media, $diskDriverName)) {
73 | $this->prepareCopyFileOnDisk($file, $media, $destination);
74 |
75 | return;
76 | }
77 |
78 | $storage = Storage::disk($file->getDisk());
79 |
80 | $headers = $diskDriverName === 'local'
81 | ? []
82 | : $this->getRemoteHeadersForFile(
83 | $file->getKey(),
84 | $media->getCustomHeaders(),
85 | $storage->mimeType($file->getKey())
86 | );
87 |
88 | $this->streamFileToDisk(
89 | $storage->getDriver()->readStream($file->getKey()),
90 | $destination,
91 | $media->disk,
92 | $headers
93 | );
94 | }
95 |
96 | protected function shouldCopyFileOnDisk(RemoteFile $file, Media $media, string $diskDriverName): bool
97 | {
98 | if ($file->getDisk() !== $media->disk) {
99 | return false;
100 | }
101 |
102 | if ($diskDriverName === 'local') {
103 | return true;
104 | }
105 |
106 | if (count($media->getCustomHeaders()) > 0) {
107 | return false;
108 | }
109 |
110 | if ((is_countable(config('media-library.remote.extra_headers')) ? count(config('media-library.remote.extra_headers')) : 0) > 0) {
111 | return false;
112 | }
113 |
114 | return true;
115 | }
116 |
117 | protected function copyFileOnDisk(string $file, string $destination, string $disk): void
118 | {
119 | $this->filesystem->disk($disk)
120 | ->copy($file, $destination);
121 | }
122 |
123 | protected function streamFileToDisk($stream, string $destination, string $disk, array $headers): void
124 | {
125 | $this->filesystem->disk($disk)
126 | ->getDriver()->writeStream(
127 | $destination,
128 | $stream,
129 | $headers
130 | );
131 | }
132 |
133 | public function copyToMediaLibrary(string $pathToFile, Media $media, ?string $type = null, ?string $targetFileName = null): void
134 | {
135 | $destinationFileName = $targetFileName ?: pathinfo($pathToFile, PATHINFO_BASENAME);
136 |
137 | $destination = $this->getMediaDirectory($media, $type).$destinationFileName;
138 |
139 | $file = fopen($pathToFile, 'r');
140 |
141 | $diskName = (in_array($type, ['conversions', 'responsiveImages']))
142 | ? $media->conversions_disk
143 | : $media->disk;
144 |
145 | $diskDriverName = (in_array($type, ['conversions', 'responsiveImages']))
146 | ? $media->getConversionsDiskDriverName()
147 | : $media->getDiskDriverName();
148 |
149 | if ($diskDriverName === 'local') {
150 | $success = $this->filesystem
151 | ->disk($diskName)
152 | ->put($destination, $file);
153 |
154 | fclose($file);
155 |
156 | if (! $success) {
157 | throw DiskCannotBeAccessed::create($diskName);
158 | }
159 |
160 | return;
161 | }
162 |
163 | $success = $this->filesystem
164 | ->disk($diskName)
165 | ->put(
166 | $destination,
167 | $file,
168 | $this->getRemoteHeadersForFile($pathToFile, $media->getCustomHeaders()),
169 | );
170 |
171 | if (is_resource($file)) {
172 | fclose($file);
173 | }
174 |
175 | if (! $success) {
176 | throw DiskCannotBeAccessed::create($diskName);
177 | }
178 | }
179 |
180 | public function addCustomRemoteHeaders(array $customRemoteHeaders): void
181 | {
182 | $this->customRemoteHeaders = $customRemoteHeaders;
183 | }
184 |
185 | public function getRemoteHeadersForFile(
186 | string $file,
187 | array $mediaCustomHeaders = [],
188 | ?string $mimeType = null
189 | ): array {
190 | $mimeTypeHeader = ['ContentType' => $mimeType ?: File::getMimeType($file)];
191 |
192 | $extraHeaders = config('media-library.remote.extra_headers');
193 |
194 | return array_merge(
195 | $mimeTypeHeader,
196 | $extraHeaders,
197 | $this->customRemoteHeaders,
198 | $mediaCustomHeaders
199 | );
200 | }
201 |
202 | public function getStream(Media $media)
203 | {
204 | $sourceFile = $this->getMediaDirectory($media).'/'.$media->file_name;
205 |
206 | return $this->filesystem->disk($media->disk)->readStream($sourceFile);
207 | }
208 |
209 | public function getConversionStream(Media $media, string $conversion)
210 | {
211 | $sourceFile = $media->getPathRelativeToRoot($conversion);
212 |
213 | return $this->filesystem->disk($media->conversions_disk)->readStream($sourceFile);
214 | }
215 |
216 | public function copyFromMediaLibrary(Media $media, string $targetFile): string
217 | {
218 | file_put_contents($targetFile, $this->getStream($media));
219 |
220 | return $targetFile;
221 | }
222 |
223 | public function removeAllFiles(Media $media): void
224 | {
225 | $fileRemover = FileRemoverFactory::create($media);
226 |
227 | $fileRemover->removeAllFiles($media);
228 | }
229 |
230 | public function removeFile(Media $media, string $path): void
231 | {
232 | $fileRemover = FileRemoverFactory::create($media);
233 |
234 | $fileRemover->removeFile($path, $media->disk);
235 | }
236 |
237 | public function removeResponsiveImages(Media $media, string $conversionName = 'media_library_original'): void
238 | {
239 | /** @var FileNamer $fileNamer */
240 | $fileNamer = app(config('media-library.file_namer'));
241 | $mediaFilename = $fileNamer->responsiveFileName($media->name);
242 |
243 | $responsiveImagesDirectory = $this->getResponsiveImagesDirectory($media);
244 |
245 | $allFilePaths = $this->filesystem->disk($media->disk)->allFiles($responsiveImagesDirectory);
246 |
247 | $responsiveImagePaths = array_filter(
248 | $allFilePaths,
249 | static fn (string $path) => Str::contains($path, $mediaFilename.'___'.$conversionName)
250 | );
251 |
252 | $this->filesystem->disk($media->disk)->delete($responsiveImagePaths);
253 | }
254 |
255 | public function syncFileNames(Media $media): void
256 | {
257 | $this->renameMediaFile($media);
258 |
259 | $this->renameConversionFiles($media);
260 | }
261 |
262 | public function syncMediaPath(Media $media): void
263 | {
264 | $factory = PathGeneratorFactory::create($media);
265 |
266 | $oldMedia = (clone $media)->fill($media->getOriginal());
267 |
268 | $oldPath = $factory->getPath($oldMedia);
269 | $newPath = $factory->getPath($media);
270 |
271 | if ($oldPath === $newPath) {
272 | return;
273 | }
274 |
275 | // If the media is stored on S3, we need to move all files in the directory
276 | if ($media->getDiskDriverName() === 's3') {
277 | $allFiles = $this->filesystem->disk($media->disk)->allFiles($oldPath);
278 |
279 | foreach ($allFiles as $file) {
280 | $newFilePath = str_replace($oldPath, $newPath, $file);
281 | $this->filesystem->disk($media->disk)->move($file, $newFilePath);
282 | }
283 |
284 | return;
285 | }
286 |
287 | $this->filesystem->disk($media->disk)->move($oldPath, $newPath);
288 | }
289 |
290 | protected function renameMediaFile(Media $media): void
291 | {
292 | $newFileName = $media->file_name;
293 | $oldFileName = $media->getOriginal('file_name');
294 |
295 | $mediaDirectory = $this->getMediaDirectory($media);
296 |
297 | $oldFile = "{$mediaDirectory}/{$oldFileName}";
298 | $newFile = "{$mediaDirectory}/{$newFileName}";
299 |
300 | $this->filesystem->disk($media->disk)->move($oldFile, $newFile);
301 | }
302 |
303 | protected function renameConversionFiles(Media $media): void
304 | {
305 | $mediaWithOldFileName = config('media-library.media_model')::find($media->getKey());
306 | $mediaWithOldFileName->file_name = $mediaWithOldFileName->getOriginal('file_name');
307 |
308 | $conversionDirectory = $this->getConversionDirectory($media);
309 |
310 | $conversionCollection = ConversionCollection::createForMedia($media);
311 |
312 | foreach ($media->getMediaConversionNames() as $conversionName) {
313 | $conversion = $conversionCollection->getByName($conversionName);
314 |
315 | $oldFile = $conversionDirectory.$conversion->getConversionFile($mediaWithOldFileName);
316 | $newFile = $conversionDirectory.$conversion->getConversionFile($media);
317 |
318 | $disk = $this->filesystem->disk($media->conversions_disk);
319 |
320 | // A media conversion file might be missing, waiting to be generated, failed etc.
321 | if (! $disk->exists($oldFile)) {
322 | continue;
323 | }
324 |
325 | $disk->move($oldFile, $newFile);
326 | }
327 | }
328 |
329 | public function getMediaDirectory(Media $media, ?string $type = null): string
330 | {
331 | $directory = null;
332 | $pathGenerator = PathGeneratorFactory::create($media);
333 |
334 | if (! $type) {
335 | $directory = $pathGenerator->getPath($media);
336 | }
337 |
338 | if ($type === 'conversions') {
339 | $directory = $pathGenerator->getPathForConversions($media);
340 | }
341 |
342 | if ($type === 'responsiveImages') {
343 | $directory = $pathGenerator->getPathForResponsiveImages($media);
344 | }
345 |
346 | return $directory;
347 | }
348 |
349 | public function getConversionDirectory(Media $media): string
350 | {
351 | return $this->getMediaDirectory($media, 'conversions');
352 | }
353 |
354 | public function getResponsiveImagesDirectory(Media $media): string
355 | {
356 | return $this->getMediaDirectory($media, 'responsiveImages');
357 | }
358 | }
359 |
--------------------------------------------------------------------------------
/src/MediaCollections/HtmlableMedia.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | use Illuminate\Contracts\Support\Htmlable;
6 | use Illuminate\Support\Arr;
7 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
8 | use Spatie\MediaLibrary\Conversions\ImageGenerators\Image;
9 | use Spatie\MediaLibrary\Conversions\ImageGenerators\ImageGeneratorFactory;
10 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
11 |
12 | class HtmlableMedia implements \Stringable, Htmlable
13 | {
14 | protected string $conversionName = '';
15 |
16 | protected array $extraAttributes = [];
17 |
18 | protected string $loadingAttributeValue = '';
19 |
20 | public function __construct(
21 | protected Media $media
22 | ) {}
23 |
24 | /**
25 | * @return $this
26 | */
27 | public function attributes(array $attributes): self
28 | {
29 | if (is_array($attributes['class'] ?? null)) {
30 | $attributes['class'] = Arr::toCssClasses($attributes['class']);
31 | }
32 |
33 | if (is_array($attributes['style'] ?? null)) {
34 | $attributes['style'] = Arr::toCssStyles($attributes['style']);
35 | }
36 |
37 | $this->extraAttributes = $attributes;
38 |
39 | return $this;
40 | }
41 |
42 | /**
43 | * @return $this
44 | */
45 | public function conversion(string $conversionName): self
46 | {
47 | $this->conversionName = $conversionName;
48 |
49 | return $this;
50 | }
51 |
52 | /**
53 | * @return $this
54 | */
55 | public function lazy(): self
56 | {
57 | $this->loadingAttributeValue = ('lazy');
58 |
59 | return $this;
60 | }
61 |
62 | public function toHtml(): string
63 | {
64 | $imageGenerator = ImageGeneratorFactory::forMedia($this->media) ?? new Image;
65 |
66 | if (! $imageGenerator->canHandleMime($this->media->mime_type)) {
67 | return '';
68 | }
69 |
70 | $attributeString = collect($this->extraAttributes)
71 | ->map(fn ($value, $name) => $name.'="'.$value.'"')->implode(' ');
72 |
73 | if (strlen($attributeString)) {
74 | $attributeString = ' '.$attributeString;
75 | }
76 |
77 | $loadingAttributeValue = config('media-library.default_loading_attribute_value');
78 |
79 | if ($this->conversionName !== '') {
80 | $conversionObject = ConversionCollection::createForMedia($this->media)->getByName($this->conversionName);
81 |
82 | $loadingAttributeValue = $conversionObject->getLoadingAttributeValue();
83 | }
84 |
85 | if ($this->loadingAttributeValue !== '') {
86 | $loadingAttributeValue = $this->loadingAttributeValue;
87 | }
88 |
89 | $viewName = 'image';
90 | $width = '';
91 | $height = '';
92 |
93 | if ($this->media->hasResponsiveImages($this->conversionName)) {
94 | $viewName = config('media-library.responsive_images.use_tiny_placeholders')
95 | ? 'responsiveImageWithPlaceholder'
96 | : 'responsiveImage';
97 |
98 | $responsiveImage = $this->media->responsiveImages($this->conversionName)->files->first();
99 |
100 | $width = $responsiveImage->width();
101 | $height = $responsiveImage->height();
102 | }
103 |
104 | $media = $this->media;
105 | $conversion = $this->conversionName;
106 |
107 | return view("media-library::{$viewName}", compact(
108 | 'media',
109 | 'conversion',
110 | 'attributeString',
111 | 'loadingAttributeValue',
112 | 'width',
113 | 'height',
114 | ))->render();
115 | }
116 |
117 | public function __toString(): string
118 | {
119 | return $this->toHtml();
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/src/MediaCollections/MediaCollection.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | use Illuminate\Support\Traits\Macroable;
6 | use InvalidArgumentException;
7 |
8 | class MediaCollection
9 | {
10 | use Macroable;
11 |
12 | public string $diskName = '';
13 |
14 | public string $conversionsDiskName = '';
15 |
16 | /** @var callable */
17 | public $mediaConversionRegistrations;
18 |
19 | public bool $generateResponsiveImages = false;
20 |
21 | /** @var callable */
22 | public $acceptsFile;
23 |
24 | public array $acceptsMimeTypes = [];
25 |
26 | /** @var bool|int */
27 | public $collectionSizeLimit = false;
28 |
29 | public bool $singleFile = false;
30 |
31 | /** @var array<string, string> */
32 | public array $fallbackUrls = [];
33 |
34 | /** @var array<string, string> */
35 | public array $fallbackPaths = [];
36 |
37 | public function __construct(
38 | public string $name
39 | ) {
40 | $this->mediaConversionRegistrations = function () {};
41 |
42 | $this->acceptsFile = fn () => true;
43 | }
44 |
45 | public static function create($name): self
46 | {
47 | return new static($name);
48 | }
49 |
50 | /**
51 | * @return $this
52 | */
53 | public function useDisk(string $diskName): self
54 | {
55 | $this->diskName = $diskName;
56 |
57 | return $this;
58 | }
59 |
60 | /**
61 | * @return $this
62 | */
63 | public function storeConversionsOnDisk(string $conversionsDiskName): self
64 | {
65 | $this->conversionsDiskName = $conversionsDiskName;
66 |
67 | return $this;
68 | }
69 |
70 | /**
71 | * @return $this
72 | */
73 | public function acceptsFile(callable $acceptsFile): self
74 | {
75 | $this->acceptsFile = $acceptsFile;
76 |
77 | return $this;
78 | }
79 |
80 | /**
81 | * @return $this
82 | */
83 | public function acceptsMimeTypes(array $mimeTypes): self
84 | {
85 | $this->acceptsMimeTypes = $mimeTypes;
86 |
87 | return $this;
88 | }
89 |
90 | public function singleFile(): self
91 | {
92 | return $this->onlyKeepLatest(1);
93 | }
94 |
95 | /**
96 | * @return $this
97 | */
98 | public function onlyKeepLatest(int $maximumNumberOfItemsInCollection): self
99 | {
100 | if ($maximumNumberOfItemsInCollection < 1) {
101 | throw new InvalidArgumentException("You should pass a value higher than 0. `{$maximumNumberOfItemsInCollection}` given.");
102 | }
103 |
104 | $this->singleFile = ($maximumNumberOfItemsInCollection === 1);
105 |
106 | $this->collectionSizeLimit = $maximumNumberOfItemsInCollection;
107 |
108 | return $this;
109 | }
110 |
111 | public function registerMediaConversions(callable $mediaConversionRegistrations): void
112 | {
113 | $this->mediaConversionRegistrations = $mediaConversionRegistrations;
114 | }
115 |
116 | /**
117 | * @return $this
118 | */
119 | public function useFallbackUrl(string $url, string $conversionName = ''): self
120 | {
121 | if ($conversionName === '') {
122 | $conversionName = 'default';
123 | }
124 |
125 | $this->fallbackUrls[$conversionName] = $url;
126 |
127 | return $this;
128 | }
129 |
130 | /**
131 | * @return $this
132 | */
133 | public function useFallbackPath(string $path, string $conversionName = ''): self
134 | {
135 | if ($conversionName === '') {
136 | $conversionName = 'default';
137 | }
138 |
139 | $this->fallbackPaths[$conversionName] = $path;
140 |
141 | return $this;
142 | }
143 |
144 | /**
145 | * @return $this
146 | */
147 | public function withResponsiveImages(): self
148 | {
149 | $this->generateResponsiveImages = true;
150 |
151 | return $this;
152 | }
153 |
154 | /**
155 | * @return $this
156 | */
157 | public function withResponsiveImagesIf($condition): self
158 | {
159 | $this->generateResponsiveImages = (bool) (is_callable($condition) ? $condition() : $condition);
160 |
161 | return $this;
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/src/MediaCollections/MediaRepository.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections;
4 |
5 | use Closure;
6 | use Illuminate\Database\Eloquent\Builder;
7 | use Illuminate\Support\Arr;
8 | use Illuminate\Support\Collection;
9 | use Illuminate\Support\LazyCollection;
10 | use Spatie\MediaLibrary\HasMedia;
11 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
12 |
13 | class MediaRepository
14 | {
15 | public function __construct(
16 | protected Media $model
17 | ) {}
18 |
19 | /**
20 | * Get all media in the collection.
21 | */
22 | public function getCollection(
23 | HasMedia $model,
24 | string $collectionName,
25 | array|callable $filter = []
26 | ): Collection {
27 | return $this->applyFilterToMediaCollection($model->loadMedia($collectionName), $filter);
28 | }
29 |
30 | /**
31 | * Apply given filters on media.
32 | */
33 | protected function applyFilterToMediaCollection(
34 | Collection $media,
35 | array|callable $filter
36 | ): Collection {
37 | if (is_array($filter)) {
38 | $filter = $this->getDefaultFilterFunction($filter);
39 | }
40 |
41 | return $media->filter($filter);
42 | }
43 |
44 | public function all(): LazyCollection
45 | {
46 | return $this->query()->cursor();
47 | }
48 |
49 | public function allIds(): Collection
50 | {
51 | return $this->query()->pluck($this->model->getKeyName());
52 | }
53 |
54 | public function getByModelType(string $modelType): LazyCollection
55 | {
56 | return $this->query()->where('model_type', $modelType)->cursor();
57 | }
58 |
59 | public function getByIds(array $ids): LazyCollection
60 | {
61 | return $this->query()->whereIn($this->model->getKeyName(), $ids)->cursor();
62 | }
63 |
64 | public function getByIdGreaterThan(int $startingFromId, bool $excludeStartingId = false, string $modelType = ''): LazyCollection
65 | {
66 | return $this->query()
67 | ->where($this->model->getKeyName(), $excludeStartingId ? '>' : '>=', $startingFromId)
68 | ->when($modelType !== '', fn (Builder $q) => $q->where('model_type', $modelType))
69 | ->cursor();
70 | }
71 |
72 | public function getByModelTypeAndCollectionName(string $modelType, string $collectionName): LazyCollection
73 | {
74 | return $this->query()
75 | ->where('model_type', $modelType)
76 | ->where('collection_name', $collectionName)
77 | ->cursor();
78 | }
79 |
80 | public function getByCollectionName(string $collectionName): LazyCollection
81 | {
82 | return $this->query()
83 | ->where('collection_name', $collectionName)
84 | ->cursor();
85 | }
86 |
87 | public function getOrphans(): LazyCollection
88 | {
89 | return $this->orphansQuery()
90 | ->cursor();
91 | }
92 |
93 | public function getOrphansByCollectionName(string $collectionName): LazyCollection
94 | {
95 | return $this->orphansQuery()
96 | ->where('collection_name', $collectionName)
97 | ->cursor();
98 | }
99 |
100 | protected function query(): Builder
101 | {
102 | return $this->model->newQuery();
103 | }
104 |
105 | protected function orphansQuery(): Builder
106 | {
107 | return $this->query()->where(fn (Builder $query) => $query->whereDoesntHave(
108 | 'model',
109 | fn (Builder $q) => $q->hasMacro('withTrashed') ? $q->withTrashed() : $q,
110 | ));
111 | }
112 |
113 | protected function getDefaultFilterFunction(array $filters): Closure
114 | {
115 | return function (Media $media) use ($filters) {
116 | foreach ($filters as $property => $value) {
117 | if (! Arr::has($media->custom_properties, $property)) {
118 | return false;
119 | }
120 |
121 | if (Arr::get($media->custom_properties, $property) !== $value) {
122 | return false;
123 | }
124 | }
125 |
126 | return true;
127 | };
128 | }
129 | }
130 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Collections/MediaCollection.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models\Collections;
4 |
5 | use Illuminate\Contracts\Support\Htmlable;
6 | use Illuminate\Database\Eloquent\Collection;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | /**
10 | * @template TKey of array-key
11 | * @template TModel of \Spatie\MediaLibrary\MediaCollections\Models\Media
12 | *
13 | * @extends Collection<TKey, TModel>
14 | */
15 | class MediaCollection extends Collection implements Htmlable
16 | {
17 | public ?string $collectionName = null;
18 |
19 | public ?string $formFieldName = null;
20 |
21 | /**
22 | * @return $this
23 | */
24 | public function collectionName(string $collectionName): self
25 | {
26 | $this->collectionName = $collectionName;
27 |
28 | return $this;
29 | }
30 |
31 | /**
32 | * @return $this
33 | */
34 | public function formFieldName(string $formFieldName): self
35 | {
36 | $this->formFieldName = $formFieldName;
37 |
38 | return $this;
39 | }
40 |
41 | public function totalSizeInBytes(): int
42 | {
43 | return $this->sum('size');
44 | }
45 |
46 | public function toHtml(): string
47 | {
48 | return e(json_encode(old($this->formFieldName ?? $this->collectionName) ?? $this->map(function (Media $media) {
49 | return [
50 | 'name' => $media->name,
51 | 'file_name' => $media->file_name,
52 | 'uuid' => $media->uuid,
53 | 'preview_url' => $media->preview_url,
54 | 'original_url' => $media->original_url,
55 | 'order' => $media->order_column,
56 | 'custom_properties' => $media->custom_properties,
57 | 'extension' => $media->extension,
58 | 'size' => $media->size,
59 | ];
60 | })->keyBy('uuid')));
61 | }
62 |
63 | public function jsonSerialize(): array
64 | {
65 | if (config('media-library.use_default_collection_serialization')) {
66 | return parent::jsonSerialize();
67 | }
68 |
69 | if (! ($this->formFieldName ?? $this->collectionName)) {
70 | return [];
71 | }
72 |
73 | return old($this->formFieldName ?? $this->collectionName) ?? $this->map(function (Media $media) {
74 | return [
75 | 'name' => $media->name,
76 | 'file_name' => $media->file_name,
77 | 'uuid' => $media->uuid,
78 | 'preview_url' => $media->preview_url,
79 | 'original_url' => $media->original_url,
80 | 'order' => $media->order_column,
81 | 'custom_properties' => $media->custom_properties,
82 | 'extension' => $media->extension,
83 | 'size' => $media->size,
84 | ];
85 | })->keyBy('uuid')->toArray();
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Concerns/CustomMediaProperties.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models\Concerns;
4 |
5 | trait CustomMediaProperties
6 | {
7 | /**
8 | * @return $this
9 | */
10 | public function setCustomHeaders(array $customHeaders): self
11 | {
12 | $this->setCustomProperty('custom_headers', $customHeaders);
13 |
14 | return $this;
15 | }
16 |
17 | public function getCustomHeaders(): array
18 | {
19 | return $this->getCustomProperty('custom_headers', []);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Concerns/HasUuid.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models\Concerns;
4 |
5 | use Illuminate\Database\Eloquent\Model;
6 | use Illuminate\Support\Str;
7 |
8 | trait HasUuid
9 | {
10 | public static function bootHasUuid(): void
11 | {
12 | static::creating(function (Model $model) {
13 | /** @var \Spatie\MediaLibrary\MediaCollections\Models\Media $model */
14 | if (empty($model->uuid)) {
15 | $model->uuid = (string) Str::uuid();
16 | }
17 | });
18 | }
19 |
20 | public static function findByUuid(string $uuid): ?Model
21 | {
22 | return static::where('uuid', $uuid)->first();
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Concerns/IsSorted.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models\Concerns;
4 |
5 | use Illuminate\Database\Eloquent\Builder;
6 |
7 | trait IsSorted
8 | {
9 | public function setHighestOrderNumber(): void
10 | {
11 | $orderColumnName = $this->determineOrderColumnName();
12 |
13 | $this->$orderColumnName = $this->getHighestOrderNumber() + 1;
14 | }
15 |
16 | public function getHighestOrderNumber(): int
17 | {
18 | return (int) static::where('model_type', $this->model_type)
19 | ->where('model_id', $this->model_id)
20 | ->max($this->determineOrderColumnName());
21 | }
22 |
23 | public function scopeOrdered(Builder $query): Builder
24 | {
25 | return $query->orderBy($this->determineOrderColumnName());
26 | }
27 |
28 | /*
29 | * This function reorders the records: the record with the first id in the array
30 | * will get the starting order (defaults to 1), the record with the second id
31 | * will get the starting order + 1, and so on.
32 | *
33 | * A starting order number can be optionally supplied.
34 | */
35 | public static function setNewOrder(array $ids, int $startOrder = 1): void
36 | {
37 | foreach ($ids as $id) {
38 | $model = static::find($id);
39 | if (! $model) {
40 | continue;
41 | }
42 |
43 | $orderColumnName = $model->determineOrderColumnName();
44 |
45 | $model->$orderColumnName = $startOrder++;
46 |
47 | $model->save();
48 | }
49 | }
50 |
51 | protected function determineOrderColumnName(): string
52 | {
53 | return $this->sortable['order_column_name'] ?? 'order_column';
54 | }
55 |
56 | public function shouldSortWhenCreating(): bool
57 | {
58 | return $this->sortable['sort_when_creating'] ?? true;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Media.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models;
4 |
5 | use Closure;
6 | use DateTimeInterface;
7 | use Illuminate\Contracts\Mail\Attachable;
8 | use Illuminate\Contracts\Support\Htmlable;
9 | use Illuminate\Contracts\Support\Responsable;
10 | use Illuminate\Database\Eloquent\Builder;
11 | use Illuminate\Database\Eloquent\Casts\Attribute;
12 | use Illuminate\Database\Eloquent\Collection as EloquentCollection;
13 | use Illuminate\Database\Eloquent\Model;
14 | use Illuminate\Database\Eloquent\Relations\BelongsTo;
15 | use Illuminate\Database\Eloquent\Relations\MorphTo;
16 | use Illuminate\Mail\Attachment;
17 | use Illuminate\Support\Arr;
18 | use Illuminate\Support\Collection;
19 | use Illuminate\Support\Str;
20 | use Spatie\MediaLibrary\Conversions\Conversion;
21 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
22 | use Spatie\MediaLibrary\Conversions\ImageGenerators\ImageGeneratorFactory;
23 | use Spatie\MediaLibrary\HasMedia;
24 | use Spatie\MediaLibrary\MediaCollections\FileAdder;
25 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
26 | use Spatie\MediaLibrary\MediaCollections\HtmlableMedia;
27 | use Spatie\MediaLibrary\MediaCollections\Models\Collections\MediaCollection;
28 | use Spatie\MediaLibrary\MediaCollections\Models\Concerns\CustomMediaProperties;
29 | use Spatie\MediaLibrary\MediaCollections\Models\Concerns\HasUuid;
30 | use Spatie\MediaLibrary\MediaCollections\Models\Concerns\IsSorted;
31 | use Spatie\MediaLibrary\ResponsiveImages\RegisteredResponsiveImages;
32 | use Spatie\MediaLibrary\Support\File;
33 | use Spatie\MediaLibrary\Support\MediaLibraryPro;
34 | use Spatie\MediaLibrary\Support\TemporaryDirectory;
35 | use Spatie\MediaLibrary\Support\UrlGenerator\UrlGenerator;
36 | use Spatie\MediaLibrary\Support\UrlGenerator\UrlGeneratorFactory;
37 | use Spatie\MediaLibraryPro\Models\TemporaryUpload;
38 | use Symfony\Component\HttpFoundation\StreamedResponse;
39 |
40 | /**
41 | * @property string $uuid
42 | * @property string $model_type
43 | * @property string|int $model_id
44 | * @property string $collection_name
45 | * @property string $name
46 | * @property string $file_name
47 | * @property string $mime_type
48 | * @property string $disk
49 | * @property string $conversions_disk
50 | * @property string $type
51 | * @property string $extension
52 | * @property-read string $humanReadableSize
53 | * @property-read string $preview_url
54 | * @property-read string $original_url
55 | * @property int $size
56 | * @property ?int $order_column
57 | * @property array $manipulations
58 | * @property array $custom_properties
59 | * @property array $generated_conversions
60 | * @property array $responsive_images
61 | * @property-read ?\Illuminate\Support\Carbon $created_at
62 | * @property-read ?\Illuminate\Support\Carbon $updated_at
63 | */
64 | class Media extends Model implements Attachable, Htmlable, Responsable
65 | {
66 | use CustomMediaProperties;
67 | use HasUuid;
68 | use IsSorted;
69 |
70 | protected $table = 'media';
71 |
72 | public const TYPE_OTHER = 'other';
73 |
74 | protected $guarded = [];
75 |
76 | protected $appends = ['original_url', 'preview_url'];
77 |
78 | protected $casts = [
79 | 'manipulations' => 'array',
80 | 'custom_properties' => 'array',
81 | 'generated_conversions' => 'array',
82 | 'responsive_images' => 'array',
83 | ];
84 |
85 | protected int $streamChunkSize = (1024 * 1024); // default to 1MB chunks.
86 |
87 | public function newCollection(array $models = []): MediaCollection
88 | {
89 | return new MediaCollection($models);
90 | }
91 |
92 | public function model(): MorphTo
93 | {
94 | return $this->morphTo();
95 | }
96 |
97 | public function getFullUrl(string $conversionName = ''): string
98 | {
99 | return url($this->getUrl($conversionName));
100 | }
101 |
102 | public function getUrl(string $conversionName = ''): string
103 | {
104 | $urlGenerator = UrlGeneratorFactory::createForMedia($this, $conversionName);
105 |
106 | return $urlGenerator->getUrl();
107 | }
108 |
109 | public function getTemporaryUrl(DateTimeInterface $expiration, string $conversionName = '', array $options = []): string
110 | {
111 | $urlGenerator = $this->getUrlGenerator($conversionName);
112 |
113 | return $urlGenerator->getTemporaryUrl($expiration, $options);
114 | }
115 |
116 | public function getPath(string $conversionName = ''): string
117 | {
118 | $urlGenerator = $this->getUrlGenerator($conversionName);
119 |
120 | return $urlGenerator->getPath();
121 | }
122 |
123 | public function getPathRelativeToRoot(string $conversionName = ''): string
124 | {
125 | return $this->getUrlGenerator($conversionName)->getPathRelativeToRoot();
126 | }
127 |
128 | public function getUrlGenerator(string $conversionName): UrlGenerator
129 | {
130 | return UrlGeneratorFactory::createForMedia($this, $conversionName);
131 | }
132 |
133 | public function getAvailableUrl(array $conversionNames): string
134 | {
135 | foreach ($conversionNames as $conversionName) {
136 | if (! $this->hasGeneratedConversion($conversionName)) {
137 | continue;
138 | }
139 |
140 | return $this->getUrl($conversionName);
141 | }
142 |
143 | return $this->getUrl();
144 | }
145 |
146 | public function getDownloadFilename(): string
147 | {
148 | return $this->file_name;
149 | }
150 |
151 | public function getAvailableFullUrl(array $conversionNames): string
152 | {
153 | foreach ($conversionNames as $conversionName) {
154 | if (! $this->hasGeneratedConversion($conversionName)) {
155 | continue;
156 | }
157 |
158 | return $this->getFullUrl($conversionName);
159 | }
160 |
161 | return $this->getFullUrl();
162 | }
163 |
164 | public function getAvailablePath(array $conversionNames): string
165 | {
166 | foreach ($conversionNames as $conversionName) {
167 | if (! $this->hasGeneratedConversion($conversionName)) {
168 | continue;
169 | }
170 |
171 | return $this->getPath($conversionName);
172 | }
173 |
174 | return $this->getPath();
175 | }
176 |
177 | protected function type(): Attribute
178 | {
179 | return Attribute::get(
180 | function () {
181 | $type = $this->getTypeFromExtension();
182 |
183 | if ($type !== self::TYPE_OTHER) {
184 | return $type;
185 | }
186 |
187 | return $this->getTypeFromMime();
188 | }
189 | );
190 | }
191 |
192 | public function getTypeFromExtension(): string
193 | {
194 | $imageGenerator = ImageGeneratorFactory::forExtension($this->extension);
195 |
196 | return $imageGenerator
197 | ? $imageGenerator->getType()
198 | : static::TYPE_OTHER;
199 | }
200 |
201 | public function getTypeFromMime(): string
202 | {
203 | $imageGenerator = ImageGeneratorFactory::forMimeType($this->mime_type);
204 |
205 | return $imageGenerator
206 | ? $imageGenerator->getType()
207 | : static::TYPE_OTHER;
208 | }
209 |
210 | protected function extension(): Attribute
211 | {
212 | return Attribute::get(fn () => pathinfo($this->file_name, PATHINFO_EXTENSION));
213 | }
214 |
215 | protected function humanReadableSize(): Attribute
216 | {
217 | return Attribute::get(fn () => File::getHumanReadableSize($this->size));
218 | }
219 |
220 | public function getDiskDriverName(): string
221 | {
222 | return strtolower(config("filesystems.disks.{$this->disk}.driver"));
223 | }
224 |
225 | public function getConversionsDiskDriverName(): string
226 | {
227 | $diskName = $this->conversions_disk ?? $this->disk;
228 |
229 | return strtolower(config("filesystems.disks.{$diskName}.driver"));
230 | }
231 |
232 | public function hasCustomProperty(string $propertyName): bool
233 | {
234 | return Arr::has($this->custom_properties, $propertyName);
235 | }
236 |
237 | /**
238 | * Get the value of custom property with the given name.
239 | *
240 | * @param mixed $default
241 | */
242 | public function getCustomProperty(string $propertyName, $default = null): mixed
243 | {
244 | return Arr::get($this->custom_properties, $propertyName, $default);
245 | }
246 |
247 | /**
248 | * @param mixed $value
249 | * @return $this
250 | */
251 | public function setCustomProperty(string $name, $value): self
252 | {
253 | $customProperties = $this->custom_properties;
254 |
255 | Arr::set($customProperties, $name, $value);
256 |
257 | $this->custom_properties = $customProperties;
258 |
259 | return $this;
260 | }
261 |
262 | /**
263 | * @return $this
264 | */
265 | public function forgetCustomProperty(string $name): self
266 | {
267 | $customProperties = $this->custom_properties;
268 |
269 | Arr::forget($customProperties, $name);
270 |
271 | $this->custom_properties = $customProperties;
272 |
273 | return $this;
274 | }
275 |
276 | public function getMediaConversionNames(): array
277 | {
278 | $conversions = ConversionCollection::createForMedia($this);
279 |
280 | return $conversions->map(fn (Conversion $conversion) => $conversion->getName())->toArray();
281 | }
282 |
283 | public function getGeneratedConversions(): Collection
284 | {
285 | return collect($this->generated_conversions ?? []);
286 | }
287 |
288 | /**
289 | * @return $this
290 | */
291 | public function markAsConversionGenerated(string $conversionName): self
292 | {
293 | $generatedConversions = $this->generated_conversions;
294 |
295 | Arr::set($generatedConversions, $conversionName, true);
296 |
297 | $this->generated_conversions = $generatedConversions;
298 |
299 | $this->saveOrTouch();
300 |
301 | return $this;
302 | }
303 |
304 | /**
305 | * @return $this
306 | */
307 | public function markAsConversionNotGenerated(string $conversionName): self
308 | {
309 | $generatedConversions = $this->generated_conversions;
310 |
311 | Arr::set($generatedConversions, $conversionName, false);
312 |
313 | $this->generated_conversions = $generatedConversions;
314 |
315 | $this->saveOrTouch();
316 |
317 | return $this;
318 | }
319 |
320 | public function hasGeneratedConversion(string $conversionName): bool
321 | {
322 | $generatedConversions = $this->generated_conversions;
323 |
324 | return Arr::get($generatedConversions, $conversionName, false);
325 | }
326 |
327 | /**
328 | * @return $this
329 | */
330 | public function setStreamChunkSize(int $chunkSize): self
331 | {
332 | $this->streamChunkSize = $chunkSize;
333 |
334 | return $this;
335 | }
336 |
337 | public function toResponse($request): StreamedResponse
338 | {
339 | return $this->buildResponse($request, 'attachment');
340 | }
341 |
342 | public function toInlineResponse($request): StreamedResponse
343 | {
344 | return $this->buildResponse($request, 'inline');
345 | }
346 |
347 | private function buildResponse($request, string $contentDispositionType): StreamedResponse
348 | {
349 | $filename = str_replace('"', '\'', Str::ascii($this->getDownloadFilename()));
350 |
351 | $downloadHeaders = [
352 | 'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
353 | 'Content-Type' => $this->mime_type,
354 | 'Content-Length' => $this->size,
355 | 'Content-Disposition' => $contentDispositionType.'; filename="'.$filename.'"',
356 | 'Pragma' => 'public',
357 | ];
358 |
359 | return response()->stream(function () {
360 | $stream = $this->stream();
361 |
362 | while (! feof($stream)) {
363 | echo fread($stream, $this->streamChunkSize);
364 | flush();
365 | }
366 |
367 | if (is_resource($stream)) {
368 | fclose($stream);
369 | }
370 | }, 200, $downloadHeaders);
371 | }
372 |
373 | public function getResponsiveImageUrls(string $conversionName = ''): array
374 | {
375 | return $this->responsiveImages($conversionName)->getUrls();
376 | }
377 |
378 | public function hasResponsiveImages(string $conversionName = ''): bool
379 | {
380 | return count($this->getResponsiveImageUrls($conversionName)) > 0;
381 | }
382 |
383 | public function getSrcset(string $conversionName = ''): string
384 | {
385 | return $this->responsiveImages($conversionName)->getSrcset();
386 | }
387 |
388 | protected function previewUrl(): Attribute
389 | {
390 | return Attribute::get(
391 | fn () => $this->hasGeneratedConversion('preview') ? $this->getUrl('preview') : '',
392 | );
393 | }
394 |
395 | protected function originalUrl(): Attribute
396 | {
397 | return Attribute::get(fn () => $this->getUrl());
398 | }
399 |
400 | /** @param string $collectionName */
401 | public function move(HasMedia $model, $collectionName = 'default', string $diskName = '', string $fileName = ''): self
402 | {
403 | $newMedia = $this->copy($model, $collectionName, $diskName, $fileName);
404 |
405 | $this->forceDelete();
406 |
407 | return $newMedia;
408 | }
409 |
410 | /**
411 | * @param null|Closure(FileAdder): FileAdder $fileAdderCallback
412 | */
413 | public function copy(
414 | HasMedia $model,
415 | string $collectionName = 'default',
416 | string $diskName = '',
417 | string $fileName = '',
418 | ?Closure $fileAdderCallback = null
419 | ): self {
420 | $temporaryDirectory = TemporaryDirectory::create();
421 |
422 | $temporaryFile = $temporaryDirectory->path('/').DIRECTORY_SEPARATOR.$this->file_name;
423 |
424 | /** @var Filesystem $filesystem */
425 | $filesystem = app(Filesystem::class);
426 |
427 | $filesystem->copyFromMediaLibrary($this, $temporaryFile);
428 |
429 | $fileAdder = $model
430 | ->addMedia($temporaryFile)
431 | ->usingName($this->name)
432 | ->setOrder($this->order_column)
433 | ->withManipulations($this->manipulations)
434 | ->withCustomProperties($this->custom_properties);
435 |
436 | if ($fileName !== '') {
437 | $fileAdder->usingFileName($fileName);
438 | }
439 |
440 | if ($fileAdderCallback instanceof Closure) {
441 | $fileAdder = $fileAdderCallback($fileAdder);
442 | }
443 |
444 | $newMedia = $fileAdder->toMediaCollection($collectionName, $diskName);
445 |
446 | $temporaryDirectory->delete();
447 |
448 | return $newMedia;
449 | }
450 |
451 | public function responsiveImages(string $conversionName = ''): RegisteredResponsiveImages
452 | {
453 | return new RegisteredResponsiveImages($this, $conversionName);
454 | }
455 |
456 | public function stream()
457 | {
458 | /** @var Filesystem $filesystem */
459 | $filesystem = app(Filesystem::class);
460 |
461 | return $filesystem->getStream($this);
462 | }
463 |
464 | public function toHtml(): string
465 | {
466 | return $this->img()->toHtml();
467 | }
468 |
469 | public function img(string $conversionName = '', $extraAttributes = []): HtmlableMedia
470 | {
471 | return (new HtmlableMedia($this))
472 | ->conversion($conversionName)
473 | ->attributes($extraAttributes);
474 | }
475 |
476 | public function __invoke(...$arguments): HtmlableMedia
477 | {
478 | return $this->img(...$arguments);
479 | }
480 |
481 | public function temporaryUpload(): BelongsTo
482 | {
483 | MediaLibraryPro::ensureInstalled();
484 |
485 | /** @var class-string<TemporaryUpload> $temporaryUploadModelClass */
486 | $temporaryUploadModelClass = config('media-library.temporary_upload_model');
487 |
488 | return $this->belongsTo($temporaryUploadModelClass);
489 | }
490 |
491 | public static function findWithTemporaryUploadInCurrentSession(array $uuids): EloquentCollection
492 | {
493 | MediaLibraryPro::ensureInstalled();
494 |
495 | /** @var class-string<TemporaryUpload> $temporaryUploadModelClass */
496 | $temporaryUploadModelClass = config('media-library.temporary_upload_model');
497 |
498 | return static::query()
499 | ->whereIn('uuid', $uuids)
500 | ->whereHasMorph(
501 | 'model',
502 | [$temporaryUploadModelClass],
503 | fn (Builder $builder) => $builder->where('session_id', session()->getId())
504 | )
505 | ->get();
506 | }
507 |
508 | public function mailAttachment(string $conversion = ''): Attachment
509 | {
510 | $attachment = Attachment::fromStorageDisk($this->disk, $this->getPathRelativeToRoot($conversion))->as($this->file_name);
511 |
512 | if ($this->mime_type) {
513 | $attachment->withMime($this->mime_type);
514 | }
515 |
516 | return $attachment;
517 | }
518 |
519 | public function toMailAttachment(): Attachment
520 | {
521 | return $this->mailAttachment();
522 | }
523 |
524 | protected function saveOrTouch(): bool
525 | {
526 | if (! $this->exists || $this->isDirty()) {
527 | return $this->save();
528 | }
529 |
530 | return $this->touch();
531 | }
532 | }
533 |
--------------------------------------------------------------------------------
/src/MediaCollections/Models/Observers/MediaObserver.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\MediaCollections\Models\Observers;
4 |
5 | use Spatie\MediaLibrary\Conversions\FileManipulator;
6 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | class MediaObserver
10 | {
11 | public function creating(Media $media): void
12 | {
13 | if ($media->shouldSortWhenCreating()) {
14 | if (is_null($media->order_column)) {
15 | $media->setHighestOrderNumber();
16 | }
17 | }
18 | }
19 |
20 | public function updating(Media $media): void
21 | {
22 | /** @var Filesystem $filesystem */
23 | $filesystem = app(Filesystem::class);
24 |
25 | if (config('media-library.moves_media_on_update')) {
26 | $filesystem->syncMediaPath($media);
27 | }
28 |
29 | if ($media->file_name !== $media->getOriginal('file_name')) {
30 | $filesystem->syncFileNames($media);
31 | }
32 | }
33 |
34 | public function updated(Media $media): void
35 | {
36 | if (is_null($media->getOriginal('model_id'))) {
37 | return;
38 | }
39 |
40 | $original = $media->getOriginal('manipulations');
41 |
42 | if ($media->manipulations !== $original) {
43 | $eventDispatcher = Media::getEventDispatcher();
44 | Media::unsetEventDispatcher();
45 |
46 | /** @var FileManipulator $fileManipulator */
47 | $fileManipulator = app(FileManipulator::class);
48 |
49 | $fileManipulator->createDerivedFiles($media);
50 |
51 | Media::setEventDispatcher($eventDispatcher);
52 | }
53 | }
54 |
55 | public function deleted(Media $media): void
56 | {
57 | if (method_exists($media, 'isForceDeleting') && ! $media->isForceDeleting()) {
58 | return;
59 | }
60 |
61 | /** @var Filesystem $filesystem */
62 | $filesystem = app(Filesystem::class);
63 |
64 | $filesystem->removeAllFiles($media);
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/MediaLibraryServiceProvider.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary;
4 |
5 | use Spatie\LaravelPackageTools\Package;
6 | use Spatie\LaravelPackageTools\PackageServiceProvider;
7 | use Spatie\MediaLibrary\Conversions\Commands\RegenerateCommand;
8 | use Spatie\MediaLibrary\MediaCollections\Commands\CleanCommand;
9 | use Spatie\MediaLibrary\MediaCollections\Commands\ClearCommand;
10 | use Spatie\MediaLibrary\MediaCollections\MediaRepository;
11 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
12 | use Spatie\MediaLibrary\MediaCollections\Models\Observers\MediaObserver;
13 | use Spatie\MediaLibrary\ResponsiveImages\TinyPlaceholderGenerator\TinyPlaceholderGenerator;
14 | use Spatie\MediaLibrary\ResponsiveImages\WidthCalculator\WidthCalculator;
15 |
16 | class MediaLibraryServiceProvider extends PackageServiceProvider
17 | {
18 | public function configurePackage(Package $package): void
19 | {
20 | $package
21 | ->name('laravel-medialibrary')
22 | ->hasConfigFile('media-library')
23 | ->hasMigration('create_media_table')
24 | ->hasViews('media-library')
25 | ->hasCommands([
26 | RegenerateCommand::class,
27 | ClearCommand::class,
28 | CleanCommand::class,
29 | ]);
30 | }
31 |
32 | public function packageBooted(): void
33 | {
34 | $mediaClass = config('media-library.media_model', Media::class);
35 | $mediaObserverClass = config('media-library.media_observer', MediaObserver::class);
36 |
37 | $mediaClass::observe(new $mediaObserverClass);
38 | }
39 |
40 | public function packageRegistered(): void
41 | {
42 | $this->app->bind(WidthCalculator::class, config('media-library.responsive_images.width_calculator'));
43 | $this->app->bind(TinyPlaceholderGenerator::class, config('media-library.responsive_images.tiny_placeholder_generator'));
44 |
45 | $this->app->scoped(MediaRepository::class, function () {
46 | $mediaClass = config('media-library.media_model');
47 |
48 | return new MediaRepository(new $mediaClass);
49 | });
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/Events/ResponsiveImagesGeneratedEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\Events;
4 |
5 | use Illuminate\Queue\SerializesModels;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class ResponsiveImagesGeneratedEvent
9 | {
10 | use SerializesModels;
11 |
12 | public function __construct(public Media $media) {}
13 | }
14 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/Exceptions/InvalidTinyJpg.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\Exceptions;
4 |
5 | use Exception;
6 | use Spatie\MediaLibrary\Support\File;
7 |
8 | class InvalidTinyJpg extends Exception
9 | {
10 | public static function doesNotExist(string $tinyImageDestinationPath): self
11 | {
12 | return new static("The expected tiny jpg at `{$tinyImageDestinationPath}` does not exist");
13 | }
14 |
15 | public static function hasWrongMimeType(string $tinyImageDestinationPath): self
16 | {
17 | $foundMimeType = File::getMimeType($tinyImageDestinationPath);
18 |
19 | return new static("Expected the file at {$tinyImageDestinationPath} have mimetype `image/jpeg`, but found a file with mimetype `{$foundMimeType}`");
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/Jobs/GenerateResponsiveImagesJob.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\Jobs;
4 |
5 | use Illuminate\Bus\Queueable;
6 | use Illuminate\Contracts\Queue\ShouldQueue;
7 | use Illuminate\Queue\InteractsWithQueue;
8 | use Illuminate\Queue\SerializesModels;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 | use Spatie\MediaLibrary\ResponsiveImages\ResponsiveImageGenerator;
11 |
12 | class GenerateResponsiveImagesJob implements ShouldQueue
13 | {
14 | use InteractsWithQueue;
15 | use Queueable;
16 | use SerializesModels;
17 |
18 | public function __construct(protected Media $media) {}
19 |
20 | public function handle(): bool
21 | {
22 | /** @var ResponsiveImageGenerator $responsiveImageGenerator */
23 | $responsiveImageGenerator = app(ResponsiveImageGenerator::class);
24 |
25 | $responsiveImageGenerator->generateResponsiveImages($this->media);
26 |
27 | return true;
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/RegisteredResponsiveImages.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class RegisteredResponsiveImages
9 | {
10 | public Collection $files;
11 |
12 | public string $generatedFor;
13 |
14 | public function __construct(protected Media $media, string $conversionName = '')
15 | {
16 | $this->generatedFor = $conversionName === ''
17 | ? 'media_library_original'
18 | : $conversionName;
19 |
20 | $this->files = collect($media->responsive_images[$this->generatedFor]['urls'] ?? [])
21 | ->map(fn (string $fileName) => new ResponsiveImage($fileName, $media))
22 | ->filter(fn (ResponsiveImage $responsiveImage) => $responsiveImage->generatedFor() === $this->generatedFor);
23 | }
24 |
25 | public function getUrls(): array
26 | {
27 | return $this->files
28 | ->map(fn (ResponsiveImage $responsiveImage) => $responsiveImage->url())
29 | ->values()
30 | ->toArray();
31 | }
32 |
33 | public function getFilenames(): array
34 | {
35 | return $this->files->pluck('fileName')->toArray();
36 | }
37 |
38 | public function getSrcset(): string
39 | {
40 | $filesSrcset = $this->files
41 | ->map(fn (ResponsiveImage $responsiveImage) => "{$responsiveImage->url()} {$responsiveImage->width()}w")
42 | ->implode(', ');
43 |
44 | $shouldAddPlaceholderSvg = config('media-library.responsive_images.use_tiny_placeholders')
45 | && $this->getPlaceholderSvg();
46 |
47 | if ($shouldAddPlaceholderSvg) {
48 | $filesSrcset .= ', '.$this->getPlaceholderSvg().' 32w';
49 | }
50 |
51 | return $filesSrcset;
52 | }
53 |
54 | public function getPlaceholderSvg(): ?string
55 | {
56 | return $this->media->responsive_images[$this->generatedFor]['base64svg'] ?? null;
57 | }
58 |
59 | public function delete(): void
60 | {
61 | $this->files->each->delete();
62 |
63 | $responsiveImages = $this->media->responsive_images;
64 |
65 | unset($responsiveImages[$this->generatedFor]);
66 |
67 | $this->media->responsive_images = $responsiveImages;
68 |
69 | $this->media->save();
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/ResponsiveImage.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 | use Spatie\MediaLibrary\Support\PathGenerator\PathGeneratorFactory;
8 | use Spatie\MediaLibrary\Support\UrlGenerator\UrlGeneratorFactory;
9 |
10 | class ResponsiveImage
11 | {
12 | public static function register(Media $media, $fileName, $conversionName): void
13 | {
14 | $responsiveImages = $media->responsive_images;
15 |
16 | $responsiveImages[$conversionName]['urls'][] = $fileName;
17 |
18 | $media->responsive_images = $responsiveImages;
19 |
20 | $media->save();
21 | }
22 |
23 | public static function registerTinySvg(Media $media, string $base64Svg, string $conversionName): void
24 | {
25 | $responsiveImages = $media->responsive_images;
26 |
27 | $responsiveImages[$conversionName]['base64svg'] = $base64Svg;
28 |
29 | $media->responsive_images = $responsiveImages;
30 |
31 | $media->save();
32 | }
33 |
34 | public function __construct(public string $fileName, public Media $media) {}
35 |
36 | public function url(): string
37 | {
38 | $conversionName = '';
39 |
40 | if ($this->generatedFor() !== 'media_library_original') {
41 | $conversionName = $this->generatedFor();
42 | }
43 |
44 | $urlGenerator = UrlGeneratorFactory::createForMedia($this->media, $conversionName);
45 |
46 | $url = $urlGenerator->getResponsiveImagesDirectoryUrl().rawurlencode($this->fileName);
47 |
48 | if (config('media-library.version_urls') === true) {
49 | $url = "{$url}?v={$this->media->updated_at->timestamp}";
50 | }
51 |
52 | return $url;
53 | }
54 |
55 | public function generatedFor(): string
56 | {
57 | $propertyParts = $this->getPropertyParts();
58 |
59 | array_pop($propertyParts);
60 |
61 | array_pop($propertyParts);
62 |
63 | return implode('_', $propertyParts);
64 | }
65 |
66 | public function width(): int
67 | {
68 | $propertyParts = $this->getPropertyParts();
69 |
70 | array_pop($propertyParts);
71 |
72 | return (int) last($propertyParts);
73 | }
74 |
75 | public function height(): int
76 | {
77 | $propertyParts = $this->getPropertyParts();
78 |
79 | return (int) last($propertyParts);
80 | }
81 |
82 | protected function getPropertyParts(): array
83 | {
84 | $propertyString = $this->stringBetween($this->fileName, '___', '.');
85 |
86 | return explode('_', $propertyString);
87 | }
88 |
89 | protected function stringBetween(string $subject, string $startCharacter, string $endCharacter): string
90 | {
91 | $lastPos = strrpos($subject, $startCharacter);
92 |
93 | $between = substr($subject, $lastPos);
94 |
95 | $between = str_replace('___', '', $between);
96 |
97 | $between = strstr($between, $endCharacter, true);
98 |
99 | return $between;
100 | }
101 |
102 | /**
103 | * @return $this
104 | */
105 | public function delete(): self
106 | {
107 | $pathGenerator = PathGeneratorFactory::create($this->media);
108 |
109 | $path = $pathGenerator->getPathForResponsiveImages($this->media);
110 |
111 | $fullPath = $path.$this->fileName;
112 |
113 | app(Filesystem::class)->removeFile($this->media, $fullPath);
114 |
115 | $responsiveImages = $this->media->responsive_images;
116 |
117 | unset($responsiveImages[$this->generatedFor()]);
118 |
119 | $this->media->responsive_images = $responsiveImages;
120 |
121 | $this->media->save();
122 |
123 | return $this;
124 | }
125 | }
126 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/ResponsiveImageGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages;
4 |
5 | use Illuminate\Support\Str;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
8 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
9 | use Spatie\MediaLibrary\ResponsiveImages\Events\ResponsiveImagesGeneratedEvent;
10 | use Spatie\MediaLibrary\ResponsiveImages\Exceptions\InvalidTinyJpg;
11 | use Spatie\MediaLibrary\ResponsiveImages\TinyPlaceholderGenerator\TinyPlaceholderGenerator;
12 | use Spatie\MediaLibrary\ResponsiveImages\WidthCalculator\WidthCalculator;
13 | use Spatie\MediaLibrary\Support\File;
14 | use Spatie\MediaLibrary\Support\FileNamer\FileNamer;
15 | use Spatie\MediaLibrary\Support\ImageFactory;
16 | use Spatie\MediaLibrary\Support\TemporaryDirectory;
17 | use Spatie\TemporaryDirectory\TemporaryDirectory as BaseTemporaryDirectory;
18 |
19 | class ResponsiveImageGenerator
20 | {
21 | protected const DEFAULT_CONVERSION_QUALITY = 90;
22 |
23 | protected FileNamer $fileNamer;
24 |
25 | public function __construct(
26 | protected Filesystem $filesystem,
27 | protected WidthCalculator $widthCalculator,
28 | protected TinyPlaceholderGenerator $tinyPlaceholderGenerator
29 | ) {
30 | $this->fileNamer = app(config('media-library.file_namer'));
31 | }
32 |
33 | public function generateResponsiveImages(Media $media): void
34 | {
35 | $temporaryDirectory = TemporaryDirectory::create();
36 |
37 | $baseImage = app(Filesystem::class)->copyFromMediaLibrary(
38 | $media,
39 | $temporaryDirectory->path(Str::random(16).'.'.$media->extension)
40 | );
41 |
42 | $media = $this->cleanResponsiveImages($media);
43 |
44 | foreach ($this->widthCalculator->calculateWidthsFromFile($baseImage) as $width) {
45 | $this->generateResponsiveImage($media, $baseImage, 'media_library_original', $width, $temporaryDirectory);
46 | }
47 |
48 | event(new ResponsiveImagesGeneratedEvent($media));
49 |
50 | $this->generateTinyJpg($media, $baseImage, 'media_library_original', $temporaryDirectory);
51 |
52 | $temporaryDirectory->delete();
53 | }
54 |
55 | public function generateResponsiveImagesForConversion(Media $media, Conversion $conversion, string $baseImage): void
56 | {
57 | $temporaryDirectory = TemporaryDirectory::create();
58 |
59 | $media = $this->cleanResponsiveImages($media, $conversion->getName());
60 |
61 | $widthCalculator = $conversion->getWidthCalculator() ?? $this->widthCalculator;
62 |
63 | foreach ($widthCalculator->calculateWidthsFromFile($baseImage) as $width) {
64 | $this->generateResponsiveImage($media, $baseImage, $conversion->getName(), $width, $temporaryDirectory, $this->getConversionQuality($conversion));
65 | }
66 |
67 | $this->generateTinyJpg($media, $baseImage, $conversion->getName(), $temporaryDirectory);
68 |
69 | $temporaryDirectory->delete();
70 | }
71 |
72 | private function getConversionQuality(Conversion $conversion): int
73 | {
74 | return $conversion->getManipulations()->getFirstManipulationArgument('quality') ?: self::DEFAULT_CONVERSION_QUALITY;
75 | }
76 |
77 | public function generateResponsiveImage(
78 | Media $media,
79 | string $baseImage,
80 | string $conversionName,
81 | int $targetWidth,
82 | BaseTemporaryDirectory $temporaryDirectory,
83 | int $conversionQuality = self::DEFAULT_CONVERSION_QUALITY
84 | ): void {
85 | $extension = $this->fileNamer->extensionFromBaseImage($baseImage);
86 | $responsiveImagePath = $this->fileNamer->temporaryFileName($media, $extension);
87 |
88 | $tempDestination = $temporaryDirectory->path($responsiveImagePath);
89 |
90 | ImageFactory::load($baseImage)
91 | ->optimize()
92 | ->width($targetWidth)
93 | ->quality($conversionQuality)
94 | ->save($tempDestination);
95 |
96 | $responsiveImageHeight = ImageFactory::load($tempDestination)->getHeight();
97 |
98 | // Users can customize the name like they want, but we expect the last part in a certain format
99 | $fileName = $this->addPropertiesToFileName(
100 | $responsiveImagePath,
101 | $conversionName,
102 | $targetWidth,
103 | $responsiveImageHeight,
104 | $extension
105 | );
106 |
107 | $responsiveImagePath = $temporaryDirectory->path($fileName);
108 |
109 | rename($tempDestination, $responsiveImagePath);
110 |
111 | $this->filesystem->copyToMediaLibrary($responsiveImagePath, $media, 'responsiveImages');
112 |
113 | ResponsiveImage::register($media, $fileName, $conversionName);
114 | }
115 |
116 | public function generateTinyJpg(
117 | Media $media,
118 | string $originalImagePath,
119 | string $conversionName,
120 | BaseTemporaryDirectory $temporaryDirectory
121 | ): void {
122 | if (! config('media-library.responsive_images.use_tiny_placeholders')) {
123 | return;
124 | }
125 |
126 | $tempDestination = $temporaryDirectory->path('tiny.jpg');
127 |
128 | $this->tinyPlaceholderGenerator->generateTinyPlaceholder($originalImagePath, $tempDestination);
129 |
130 | $this->guardAgainstInvalidTinyPlaceHolder($tempDestination);
131 |
132 | $tinyImageDataBase64 = base64_encode(file_get_contents($tempDestination));
133 |
134 | $tinyImageBase64 = 'data:image/jpeg;base64,'.$tinyImageDataBase64;
135 |
136 | $originalImage = ImageFactory::load($originalImagePath);
137 |
138 | $originalImageWidth = $originalImage->getWidth();
139 |
140 | $originalImageHeight = $originalImage->getHeight();
141 |
142 | $svg = view('media-library::placeholderSvg', compact(
143 | 'originalImageWidth',
144 | 'originalImageHeight',
145 | 'tinyImageBase64'
146 | ));
147 |
148 | $base64Svg = 'data:image/svg+xml;base64,'.base64_encode($svg);
149 |
150 | ResponsiveImage::registerTinySvg($media, $base64Svg, $conversionName);
151 | }
152 |
153 | protected function appendToFileName(string $filePath, string $suffix, ?string $extensionFilePath = null): string
154 | {
155 | $baseName = pathinfo($filePath, PATHINFO_FILENAME);
156 |
157 | $extension = pathinfo($extensionFilePath ?? $filePath, PATHINFO_EXTENSION);
158 |
159 | return "{$baseName}{$suffix}.{$extension}";
160 | }
161 |
162 | protected function guardAgainstInvalidTinyPlaceHolder(string $tinyPlaceholderPath): void
163 | {
164 | if (! file_exists($tinyPlaceholderPath)) {
165 | throw InvalidTinyJpg::doesNotExist($tinyPlaceholderPath);
166 | }
167 |
168 | if (File::getMimeType($tinyPlaceholderPath) !== 'image/jpeg') {
169 | throw InvalidTinyJpg::hasWrongMimeType($tinyPlaceholderPath);
170 | }
171 | }
172 |
173 | protected function cleanResponsiveImages(Media $media, string $conversionName = 'media_library_original'): Media
174 | {
175 | $responsiveImages = $media->responsive_images;
176 | $responsiveImages[$conversionName]['urls'] = [];
177 | $media->responsive_images = $responsiveImages;
178 |
179 | $this->filesystem->removeResponsiveImages($media, $conversionName);
180 |
181 | return $media;
182 | }
183 |
184 | protected function addPropertiesToFileName(string $fileName, string $conversionName, int $width, int $height, string $extension): string
185 | {
186 | $fileName = pathinfo($fileName, PATHINFO_FILENAME);
187 |
188 | return "{$fileName}___{$conversionName}_{$width}_{$height}.{$extension}";
189 | }
190 | }
191 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/TinyPlaceholderGenerator/Blurred.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\TinyPlaceholderGenerator;
4 |
5 | use Spatie\MediaLibrary\Support\ImageFactory;
6 |
7 | class Blurred implements TinyPlaceholderGenerator
8 | {
9 | public function generateTinyPlaceholder(string $sourceImagePath, string $tinyImageDestinationPath): void
10 | {
11 | $sourceImage = ImageFactory::load($sourceImagePath);
12 |
13 | $sourceImage->width(32)->blur(5)->save($tinyImageDestinationPath);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/TinyPlaceholderGenerator/TinyPlaceholderGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\TinyPlaceholderGenerator;
4 |
5 | interface TinyPlaceholderGenerator
6 | {
7 | /*
8 | * This function should generate a tiny jpg representation of the image
9 | * given in $sourceImage. The tiny jpg should be saved at $tinyImageDestination.
10 | */
11 | public function generateTinyPlaceholder(string $sourceImage, string $tinyImageDestination): void;
12 | }
13 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/WidthCalculator/FileSizeOptimizedWidthCalculator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\WidthCalculator;
4 |
5 | use Illuminate\Support\Collection;
6 | use Spatie\MediaLibrary\Support\ImageFactory;
7 |
8 | class FileSizeOptimizedWidthCalculator implements WidthCalculator
9 | {
10 | public function calculateWidthsFromFile(string $imagePath): Collection
11 | {
12 | $image = ImageFactory::load($imagePath);
13 |
14 | $width = $image->getWidth();
15 | $height = $image->getHeight();
16 | $fileSize = filesize($imagePath);
17 |
18 | return $this->calculateWidths($fileSize, $width, $height);
19 | }
20 |
21 | public function calculateWidths(int $fileSize, int $width, int $height): Collection
22 | {
23 | $targetWidths = collect();
24 |
25 | $targetWidths->push($width);
26 |
27 | $ratio = $height / $width;
28 | $area = $height * $width;
29 |
30 | $predictedFileSize = $fileSize;
31 | $pixelPrice = $predictedFileSize / $area;
32 |
33 | while (true) {
34 | $predictedFileSize *= 0.7;
35 |
36 | $newWidth = (int) floor(sqrt(($predictedFileSize / $pixelPrice) / $ratio));
37 |
38 | if ($this->finishedCalculating((int) $predictedFileSize, $newWidth)) {
39 | return $targetWidths;
40 | }
41 |
42 | $targetWidths->push($newWidth);
43 | }
44 | }
45 |
46 | protected function finishedCalculating(int $predictedFileSize, int $newWidth): bool
47 | {
48 | if ($newWidth < 20) {
49 | return true;
50 | }
51 |
52 | if ($predictedFileSize < (1024 * 10)) {
53 | return true;
54 | }
55 |
56 | return false;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/ResponsiveImages/WidthCalculator/WidthCalculator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\ResponsiveImages\WidthCalculator;
4 |
5 | use Illuminate\Support\Collection;
6 |
7 | interface WidthCalculator
8 | {
9 | public function calculateWidthsFromFile(string $imagePath): Collection;
10 |
11 | public function calculateWidths(int $fileSize, int $width, int $height): Collection;
12 | }
13 |
--------------------------------------------------------------------------------
/src/Support/Factories/TemporaryUploadFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\Factories;
4 |
5 | class TemporaryUploadFactory {}
6 |
--------------------------------------------------------------------------------
/src/Support/File.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | use Symfony\Component\Mime\MimeTypes;
6 |
7 | class File
8 | {
9 | public static function getHumanReadableSize(int|float $sizeInBytes): string
10 | {
11 | $units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
12 |
13 | // 0 === 0.00 return false so use double equals
14 | if ($sizeInBytes == 0) {
15 | return '0 '.$units[0];
16 | }
17 |
18 | $index = min(count($units) - 1, floor(log(abs($sizeInBytes), 1024)));
19 |
20 | return sprintf('%s %s', round(num: abs($sizeInBytes) / (1024 ** $index), precision: 2), $units[$index]);
21 | }
22 |
23 | public static function getMimeType(string $path): string
24 | {
25 | return (string) MimeTypes::getDefault()->guessMimeType($path);
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/Support/FileNamer/DefaultFileNamer.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileNamer;
4 |
5 | use Spatie\MediaLibrary\Conversions\Conversion;
6 |
7 | class DefaultFileNamer extends FileNamer
8 | {
9 | public function conversionFileName(string $fileName, Conversion $conversion): string
10 | {
11 | $strippedFileName = pathinfo($fileName, PATHINFO_FILENAME);
12 |
13 | return "{$strippedFileName}-{$conversion->getName()}";
14 | }
15 |
16 | public function responsiveFileName(string $fileName): string
17 | {
18 | return pathinfo($fileName, PATHINFO_FILENAME);
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/src/Support/FileNamer/FileNamer.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileNamer;
4 |
5 | use Spatie\MediaLibrary\Conversions\Conversion;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | abstract class FileNamer
9 | {
10 | public function originalFileName(string $fileName): string
11 | {
12 | $extLength = strlen(pathinfo($fileName, PATHINFO_EXTENSION));
13 |
14 | $baseName = substr($fileName, 0, strlen($fileName) - ($extLength ? $extLength + 1 : 0));
15 |
16 | return $baseName;
17 | }
18 |
19 | abstract public function conversionFileName(string $fileName, Conversion $conversion): string;
20 |
21 | abstract public function responsiveFileName(string $fileName): string;
22 |
23 | public function temporaryFileName(Media $media, string $extension): string
24 | {
25 | return "{$this->responsiveFileName($media->file_name)}.{$extension}";
26 | }
27 |
28 | public function extensionFromBaseImage(string $baseImage): string
29 | {
30 | return pathinfo($baseImage, PATHINFO_EXTENSION);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/Support/FileRemover/DefaultFileRemover.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileRemover;
4 |
5 | use Exception;
6 | use Illuminate\Contracts\Filesystem\Factory;
7 | use Illuminate\Support\Str;
8 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 | use Spatie\MediaLibrary\Support\FileNamer\FileNamer;
11 | use Spatie\MediaLibrary\Support\PathGenerator\PathGeneratorFactory;
12 |
13 | class DefaultFileRemover implements FileRemover
14 | {
15 | public function __construct(protected Filesystem $mediaFileSystem, protected Factory $filesystem) {}
16 |
17 | public function removeAllFiles(Media $media): void
18 | {
19 |
20 | if ($media->conversions_disk && $media->disk !== $media->conversions_disk) {
21 | $this->removeFromConversionsDirectory($media, $media->conversions_disk);
22 | $this->removeFromResponsiveImagesDirectory($media, $media->conversions_disk);
23 | $this->removeFromMediaDirectory($media, $media->conversions_disk);
24 | }
25 |
26 | $this->removeFromConversionsDirectory($media, $media->disk);
27 | $this->removeFromResponsiveImagesDirectory($media, $media->disk);
28 | $this->removeFromMediaDirectory($media, $media->disk);
29 | }
30 |
31 | public function removeFromMediaDirectory(Media $media, string $disk): void
32 | {
33 | $mediaDirectory = $this->mediaFileSystem->getMediaDirectory($media);
34 |
35 | collect([$mediaDirectory])
36 | ->each(function (string $directory) use ($media, $disk) {
37 | try {
38 | $allFilePaths = $this->filesystem->disk($disk)->allFiles($directory);
39 | $imagePaths = array_filter(
40 | $allFilePaths,
41 | static fn (string $path) => Str::afterLast($path, '/') === $media->file_name
42 | );
43 | foreach ($imagePaths as $imagePath) {
44 | $this->filesystem->disk($disk)->delete($imagePath);
45 | }
46 |
47 | if (! $this->filesystem->disk($disk)->allFiles($directory)) {
48 | $this->filesystem->disk($disk)->deleteDirectory($directory);
49 | }
50 | } catch (Exception $exception) {
51 | report($exception);
52 | }
53 | });
54 |
55 | }
56 |
57 | public function removeFromConversionsDirectory(Media $media, string $disk): void
58 | {
59 | $conversionsDirectory = $this->mediaFileSystem->getMediaDirectory($media, 'conversions');
60 |
61 | collect([$conversionsDirectory])
62 | ->each(function (string $directory) use ($media, $disk) {
63 | try {
64 | $allFilePaths = $this->filesystem->disk($disk)->allFiles($directory);
65 | $conversions = $media->getMediaConversionNames() ?: [];
66 | $conversionsFilePaths = array_map(
67 | static fn (string $conversion) => $media->getPathRelativeToRoot($conversion),
68 | $conversions,
69 | );
70 | $imagePaths = array_intersect($allFilePaths, $conversionsFilePaths);
71 | foreach ($imagePaths as $imagePath) {
72 | $this->filesystem->disk($disk)->delete($imagePath);
73 | }
74 |
75 | if (! $this->filesystem->disk($disk)->allFiles($directory)) {
76 | $this->filesystem->disk($disk)->deleteDirectory($directory);
77 | }
78 | } catch (Exception $exception) {
79 | report($exception);
80 | }
81 | });
82 | }
83 |
84 | public function removeFromResponsiveImagesDirectory(Media $media, string $disk): void
85 | {
86 | $responsiveImagesDirectory = $this->mediaFileSystem->getMediaDirectory($media, 'responsiveImages');
87 | $mediaRoot = PathGeneratorFactory::create($media)->getPathForResponsiveImages($media);
88 | /** @var FileNamer $fileNamer */
89 | $fileNamer = app(config('media-library.file_namer'));
90 | $mediaFilename = $fileNamer->responsiveFileName($media->file_name);
91 |
92 | collect([$responsiveImagesDirectory])
93 | ->unique()
94 | ->each(function (string $directory) use ($media, $disk, $mediaRoot, $mediaFilename) {
95 | try {
96 | $allFilePaths = $this->filesystem->disk($disk)->allFiles($directory);
97 |
98 | $conversions = $media->getMediaConversionNames() ?: [];
99 | $responsiveImagesFilePaths = collect($conversions)
100 | ->flatMap(static fn (string $conversion) => $media->responsiveImages($conversion)->getFilenames())
101 | ->map(static fn (string $imagePath) => $mediaRoot.$imagePath)
102 | ->toArray();
103 |
104 | $imagePaths = array_merge(
105 | array_intersect($allFilePaths, $responsiveImagesFilePaths),
106 | array_filter(
107 | $allFilePaths,
108 | static fn (string $path) => Str::startsWith($path, $mediaRoot.$mediaFilename.'___media_library_original_'),
109 | ),
110 | );
111 |
112 | foreach ($imagePaths as $imagePath) {
113 | $this->filesystem->disk($disk)->delete($imagePath);
114 | }
115 |
116 | if (! $this->filesystem->disk($disk)->allFiles($directory)) {
117 | $this->filesystem->disk($disk)->deleteDirectory($directory);
118 | }
119 | } catch (Exception $exception) {
120 | report($exception);
121 | }
122 | });
123 | }
124 |
125 | public function removeResponsiveImages(Media $media, string $conversionName): void
126 | {
127 | $responsiveImagesDirectory = $this->mediaFileSystem->getResponsiveImagesDirectory($media);
128 |
129 | $allFilePaths = $this->filesystem->disk($media->disk)->allFiles($responsiveImagesDirectory);
130 |
131 | $responsiveImagePaths = array_filter(
132 | $allFilePaths,
133 | fn (string $path) => Str::contains($path, $conversionName)
134 | );
135 |
136 | $this->filesystem->disk($media->disk)->delete($responsiveImagePaths);
137 | }
138 |
139 | public function removeFile(string $path, string $disk): void
140 | {
141 | $this->filesystem->disk($disk)->delete($path);
142 | }
143 | }
144 |
--------------------------------------------------------------------------------
/src/Support/FileRemover/FileBaseFileRemover.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileRemover;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
6 |
7 | class FileBaseFileRemover extends DefaultFileRemover
8 | {
9 | public function removeAllFiles(Media $media): void
10 | {
11 | $this->removeFile($this->mediaFileSystem->getMediaDirectory($media).$media->file_name, $media->disk);
12 |
13 | $this->removeConvertedImages($media);
14 | }
15 |
16 | public function removeConvertedImages(Media $media): void
17 | {
18 | collect($media->getMediaConversionNames())->each(function ($conversionName) use ($media) {
19 | $this->removeFile(
20 | path: $media->getPathRelativeToRoot($conversionName),
21 | disk: $media->conversions_disk
22 | );
23 |
24 | $this->mediaFileSystem->removeResponsiveImages($media, $conversionName);
25 | });
26 | }
27 |
28 | public function removeFile(string $path, string $disk): void
29 | {
30 | $this->filesystem->disk($disk)->delete($path);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/Support/FileRemover/FileRemover.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileRemover;
4 |
5 | use Illuminate\Contracts\Filesystem\Factory;
6 | use Spatie\MediaLibrary\MediaCollections\Filesystem;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | interface FileRemover
10 | {
11 | public function __construct(Filesystem $mediaFileSystem, Factory $filesystem);
12 |
13 | /*
14 | * Remove all files relating to the media model.
15 | */
16 | public function removeAllFiles(Media $media): void;
17 |
18 | /*
19 | * Remove responsive files relating to the media model.
20 | */
21 | public function removeResponsiveImages(Media $media, string $conversionName): void;
22 |
23 | /*
24 | * Remove a file relating to the media model.
25 | */
26 | public function removeFile(string $path, string $disk): void;
27 | }
28 |
--------------------------------------------------------------------------------
/src/Support/FileRemover/FileRemoverFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\FileRemover;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Exceptions\InvalidFileRemover;
6 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
7 |
8 | class FileRemoverFactory
9 | {
10 | public static function create(Media $media): FileRemover
11 | {
12 | $fileRemoverClass = config('media-library.file_remover_class');
13 |
14 | static::guardAgainstInvalidFileRemover($fileRemoverClass);
15 |
16 | return app($fileRemoverClass);
17 | }
18 |
19 | protected static function guardAgainstInvalidFileRemover(string $fileRemoverClass): void
20 | {
21 | if (! class_exists($fileRemoverClass)) {
22 | throw InvalidFileRemover::doesntExist($fileRemoverClass);
23 | }
24 |
25 | if (! is_subclass_of($fileRemoverClass, FileRemover::class)) {
26 | throw InvalidFileRemover::doesNotImplementFileRemover($fileRemoverClass);
27 | }
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/Support/ImageFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | use Spatie\Image\Drivers\ImageDriver;
6 | use Spatie\Image\Image;
7 |
8 | class ImageFactory
9 | {
10 | public static function load(string $path): ImageDriver
11 | {
12 | return Image::useImageDriver(config('media-library.image_driver'))
13 | ->loadFile($path);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/src/Support/MediaLibraryPro.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Exceptions\FunctionalityNotAvailable;
6 | use Spatie\MediaLibraryPro\Models\TemporaryUpload;
7 |
8 | class MediaLibraryPro
9 | {
10 | public static function ensureInstalled(): void
11 | {
12 | if (! self::isInstalled()) {
13 | throw FunctionalityNotAvailable::mediaLibraryProRequired();
14 | }
15 | }
16 |
17 | public static function isInstalled(): bool
18 | {
19 | return class_exists(TemporaryUpload::class);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/Support/MediaStream.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | use Illuminate\Contracts\Support\Responsable;
6 | use Illuminate\Support\Collection;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 | use Symfony\Component\HttpFoundation\StreamedResponse;
9 | use ZipStream\ZipStream;
10 |
11 | class MediaStream implements Responsable
12 | {
13 | protected Collection $mediaItems;
14 |
15 | protected array $zipOptions;
16 |
17 | public static function create(string $zipName): self
18 | {
19 | return new static($zipName);
20 | }
21 |
22 | public function __construct(protected string $zipName)
23 | {
24 | $this->mediaItems = collect();
25 |
26 | $this->zipOptions = [];
27 | }
28 |
29 | /**
30 | * @return $this
31 | */
32 | public function useZipOptions(callable $zipOptionsCallable): self
33 | {
34 | $zipOptionsCallable($this->zipOptions);
35 |
36 | return $this;
37 | }
38 |
39 | /**
40 | * @return $this
41 | */
42 | public function addMedia(...$mediaItems): self
43 | {
44 | collect($mediaItems)
45 | ->flatMap(function ($item) {
46 | if ($item instanceof Media) {
47 | return [$item];
48 | }
49 |
50 | if ($item instanceof Collection) {
51 | return $item->reduce(function (array $carry, Media $media) {
52 | $carry[] = $media;
53 |
54 | return $carry;
55 | }, []);
56 | }
57 |
58 | return $item;
59 | })
60 | ->each(fn (Media $media) => $this->mediaItems->push($media));
61 |
62 | return $this;
63 | }
64 |
65 | public function getMediaItems(): Collection
66 | {
67 | return $this->mediaItems;
68 | }
69 |
70 | public function toResponse($request): StreamedResponse
71 | {
72 | $headers = [
73 | 'Content-Disposition' => "attachment; filename=\"{$this->zipName}\"",
74 | 'Content-Type' => 'application/octet-stream',
75 | ];
76 |
77 | return new StreamedResponse(fn () => $this->getZipStream(), 200, $headers);
78 | }
79 |
80 | public function getZipStream(): ZipStream
81 | {
82 | $this->zipOptions['outputName'] = $this->zipName;
83 | $zip = new ZipStream(...$this->zipOptions);
84 |
85 | $this->getZipStreamContents()->each(function (array $mediaInZip) use ($zip) {
86 | $stream = $mediaInZip['media']->stream();
87 |
88 | $zip->addFileFromStream($mediaInZip['fileNameInZip'], $stream);
89 |
90 | if (is_resource($stream)) {
91 | fclose($stream);
92 | }
93 | });
94 |
95 | $zip->finish();
96 |
97 | return $zip;
98 | }
99 |
100 | protected function getZipStreamContents(): Collection
101 | {
102 |
103 | return $this->mediaItems->map(fn (Media $media, $mediaItemIndex) => [
104 | 'fileNameInZip' => $this->getZipFileNamePrefix($this->mediaItems, $mediaItemIndex).$this->getFileNameWithSuffix($this->mediaItems, $mediaItemIndex),
105 | 'media' => $media,
106 | ]);
107 | }
108 |
109 | protected function getFileNameWithSuffix(Collection $mediaItems, int $currentIndex): string
110 | {
111 | $fileNameCount = 0;
112 |
113 | $fileName = $mediaItems[$currentIndex]->getDownloadFilename();
114 |
115 | foreach ($mediaItems as $index => $media) {
116 | if ($index >= $currentIndex) {
117 | break;
118 | }
119 |
120 | if ($this->getZipFileNamePrefix($mediaItems, $index).$media->getDownloadFilename() === $this->getZipFileNamePrefix($mediaItems, $currentIndex).$fileName) {
121 | $fileNameCount++;
122 | }
123 | }
124 |
125 | if ($fileNameCount === 0) {
126 | return $fileName;
127 | }
128 |
129 | $extension = pathinfo($fileName, PATHINFO_EXTENSION);
130 | $fileNameWithoutExtension = pathinfo($fileName, PATHINFO_FILENAME);
131 |
132 | return "{$fileNameWithoutExtension} ({$fileNameCount}).{$extension}";
133 | }
134 |
135 | protected function getZipFileNamePrefix(Collection $mediaItems, int $currentIndex): string
136 | {
137 | return $mediaItems[$currentIndex]->hasCustomProperty('zip_filename_prefix') ? $mediaItems[$currentIndex]->getCustomProperty('zip_filename_prefix') : '';
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/src/Support/PathGenerator/DefaultPathGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\PathGenerator;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
6 |
7 | class DefaultPathGenerator implements PathGenerator
8 | {
9 | /*
10 | * Get the path for the given media, relative to the root storage path.
11 | */
12 | public function getPath(Media $media): string
13 | {
14 | return $this->getBasePath($media).'/';
15 | }
16 |
17 | /*
18 | * Get the path for conversions of the given media, relative to the root storage path.
19 | */
20 | public function getPathForConversions(Media $media): string
21 | {
22 | return $this->getBasePath($media).'/conversions/';
23 | }
24 |
25 | /*
26 | * Get the path for responsive images of the given media, relative to the root storage path.
27 | */
28 | public function getPathForResponsiveImages(Media $media): string
29 | {
30 | return $this->getBasePath($media).'/responsive-images/';
31 | }
32 |
33 | /*
34 | * Get a unique base path for the given media.
35 | */
36 | protected function getBasePath(Media $media): string
37 | {
38 | $prefix = config('media-library.prefix', '');
39 |
40 | if ($prefix !== '') {
41 | return $prefix.'/'.$media->getKey();
42 | }
43 |
44 | return $media->getKey();
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/Support/PathGenerator/PathGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\PathGenerator;
4 |
5 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
6 |
7 | interface PathGenerator
8 | {
9 | /*
10 | * Get the path for the given media, relative to the root storage path.
11 | */
12 | public function getPath(Media $media): string;
13 |
14 | /*
15 | * Get the path for conversions of the given media, relative to the root storage path.
16 | */
17 | public function getPathForConversions(Media $media): string;
18 |
19 | /*
20 | * Get the path for responsive images of the given media, relative to the root storage path.
21 | */
22 | public function getPathForResponsiveImages(Media $media): string;
23 | }
24 |
--------------------------------------------------------------------------------
/src/Support/PathGenerator/PathGeneratorFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\PathGenerator;
4 |
5 | use Illuminate\Database\Eloquent\Relations\Relation;
6 | use Spatie\MediaLibrary\MediaCollections\Exceptions\InvalidPathGenerator;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 |
9 | class PathGeneratorFactory
10 | {
11 | public static function create(Media $media): PathGenerator
12 | {
13 | $pathGeneratorClass = static::getPathGeneratorClass($media);
14 |
15 | static::guardAgainstInvalidPathGenerator($pathGeneratorClass);
16 |
17 | return app($pathGeneratorClass);
18 | }
19 |
20 | protected static function getPathGeneratorClass(Media $media)
21 | {
22 | $defaultPathGeneratorClass = config('media-library.path_generator');
23 |
24 | foreach (config('media-library.custom_path_generators', []) as $modelClass => $customPathGeneratorClass) {
25 | if (static::mediaBelongToModelClass($media, $modelClass)) {
26 | return $customPathGeneratorClass;
27 | }
28 | }
29 |
30 | return $defaultPathGeneratorClass;
31 | }
32 |
33 | protected static function mediaBelongToModelClass(Media $media, string $modelClass): bool
34 | {
35 | // model doesn't have morphMap, so morph type and class are equal
36 | if (is_a($media->model_type, $modelClass, true)) {
37 | return true;
38 | }
39 | // config is set via morphMap alias
40 | if ($media->model_type === $modelClass) {
41 | return true;
42 | }
43 | // config is set via morphMap class name
44 | if (is_a((string) Relation::getMorphedModel($media->model_type), $modelClass, true)) {
45 | return true;
46 | }
47 |
48 | return false;
49 | }
50 |
51 | protected static function guardAgainstInvalidPathGenerator(string $pathGeneratorClass): void
52 | {
53 | if (! class_exists($pathGeneratorClass)) {
54 | throw InvalidPathGenerator::doesntExist($pathGeneratorClass);
55 | }
56 |
57 | if (! is_subclass_of($pathGeneratorClass, PathGenerator::class)) {
58 | throw InvalidPathGenerator::doesNotImplementPathGenerator($pathGeneratorClass);
59 | }
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/Support/RemoteFile.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | class RemoteFile
6 | {
7 | public function __construct(protected string $key, protected string $disk) {}
8 |
9 | public function getKey(): string
10 | {
11 | return $this->key;
12 | }
13 |
14 | public function getDisk(): string
15 | {
16 | return $this->disk;
17 | }
18 |
19 | public function getFilename(): string
20 | {
21 | return basename($this->key);
22 | }
23 |
24 | public function getName(): string
25 | {
26 | return pathinfo($this->getFilename(), PATHINFO_FILENAME);
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/Support/TemporaryDirectory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support;
4 |
5 | use Illuminate\Support\Str;
6 | use Spatie\TemporaryDirectory\TemporaryDirectory as BaseTemporaryDirectory;
7 |
8 | class TemporaryDirectory
9 | {
10 | public static function create(): BaseTemporaryDirectory
11 | {
12 | return new BaseTemporaryDirectory(static::getTemporaryDirectoryPath());
13 | }
14 |
15 | protected static function getTemporaryDirectoryPath(): string
16 | {
17 | $path = config('media-library.temporary_directory_path') ?? storage_path('media-library/temp');
18 |
19 | return $path.DIRECTORY_SEPARATOR.Str::random(32);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/Support/UrlGenerator/BaseUrlGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\UrlGenerator;
4 |
5 | use Illuminate\Contracts\Config\Repository as Config;
6 | use Illuminate\Contracts\Filesystem\Filesystem;
7 | use Illuminate\Support\Facades\Storage;
8 | use Spatie\MediaLibrary\Conversions\Conversion;
9 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
10 | use Spatie\MediaLibrary\Support\PathGenerator\PathGenerator;
11 |
12 | abstract class BaseUrlGenerator implements UrlGenerator
13 | {
14 | protected ?Media $media = null;
15 |
16 | protected ?Conversion $conversion = null;
17 |
18 | protected ?PathGenerator $pathGenerator = null;
19 |
20 | public function __construct(protected Config $config) {}
21 |
22 | /**
23 | * @return $this
24 | */
25 | public function setMedia(Media $media): UrlGenerator
26 | {
27 | $this->media = $media;
28 |
29 | return $this;
30 | }
31 |
32 | /**
33 | * @return $this
34 | */
35 | public function setConversion(Conversion $conversion): UrlGenerator
36 | {
37 | $this->conversion = $conversion;
38 |
39 | return $this;
40 | }
41 |
42 | /**
43 | * @return $this
44 | */
45 | public function setPathGenerator(PathGenerator $pathGenerator): UrlGenerator
46 | {
47 | $this->pathGenerator = $pathGenerator;
48 |
49 | return $this;
50 | }
51 |
52 | public function getPathRelativeToRoot(): string
53 | {
54 | if (is_null($this->conversion)) {
55 | return $this->pathGenerator->getPath($this->media).($this->media->file_name);
56 | }
57 |
58 | return $this->pathGenerator->getPathForConversions($this->media)
59 | .$this->conversion->getConversionFile($this->media);
60 | }
61 |
62 | protected function getDiskName(): string
63 | {
64 | return $this->conversion === null
65 | ? $this->media->disk
66 | : $this->media->conversions_disk;
67 | }
68 |
69 | protected function getDisk(): Filesystem
70 | {
71 | return Storage::disk($this->getDiskName());
72 | }
73 |
74 | public function versionUrl(string $path = ''): string
75 | {
76 | if (! $this->config->get('media-library.version_urls')) {
77 | return $path;
78 | }
79 |
80 | return "{$path}?v={$this->media->updated_at->timestamp}";
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/Support/UrlGenerator/DefaultUrlGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\UrlGenerator;
4 |
5 | use DateTimeInterface;
6 | use Illuminate\Support\Str;
7 |
8 | class DefaultUrlGenerator extends BaseUrlGenerator
9 | {
10 | public function getUrl(): string
11 | {
12 | $url = $this->getDisk()->url($this->getPathRelativeToRoot());
13 |
14 | return $this->versionUrl($url);
15 | }
16 |
17 | public function getTemporaryUrl(DateTimeInterface $expiration, array $options = []): string
18 | {
19 | return $this->getDisk()->temporaryUrl($this->getPathRelativeToRoot(), $expiration, $options);
20 | }
21 |
22 | public function getBaseMediaDirectoryUrl(): string
23 | {
24 | return $this->getDisk()->url('/');
25 | }
26 |
27 | public function getPath(): string
28 | {
29 | return $this->getRootOfDisk().$this->getPathRelativeToRoot();
30 | }
31 |
32 | public function getResponsiveImagesDirectoryUrl(): string
33 | {
34 | $path = $this->pathGenerator->getPathForResponsiveImages($this->media);
35 |
36 | return Str::finish($this->getDisk()->url($path), '/');
37 | }
38 |
39 | protected function getRootOfDisk(): string
40 | {
41 | return $this->getDisk()->path('/');
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/Support/UrlGenerator/UrlGenerator.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\UrlGenerator;
4 |
5 | use DateTimeInterface;
6 | use Spatie\MediaLibrary\Conversions\Conversion;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 | use Spatie\MediaLibrary\Support\PathGenerator\PathGenerator;
9 |
10 | interface UrlGenerator
11 | {
12 | public function getUrl(): string;
13 |
14 | public function getPath(): string;
15 |
16 | public function setMedia(Media $media): self;
17 |
18 | public function setConversion(Conversion $conversion): self;
19 |
20 | public function setPathGenerator(PathGenerator $pathGenerator): self;
21 |
22 | /**
23 | * @param array<string, mixed> $options
24 | */
25 | public function getTemporaryUrl(DateTimeInterface $expiration, array $options = []): string;
26 |
27 | public function getResponsiveImagesDirectoryUrl(): string;
28 | }
29 |
--------------------------------------------------------------------------------
/src/Support/UrlGenerator/UrlGeneratorFactory.php:
--------------------------------------------------------------------------------
1 | <?php
2 |
3 | namespace Spatie\MediaLibrary\Support\UrlGenerator;
4 |
5 | use Spatie\MediaLibrary\Conversions\ConversionCollection;
6 | use Spatie\MediaLibrary\MediaCollections\Exceptions\InvalidUrlGenerator;
7 | use Spatie\MediaLibrary\MediaCollections\Models\Media;
8 | use Spatie\MediaLibrary\Support\PathGenerator\PathGeneratorFactory;
9 |
10 | class UrlGeneratorFactory
11 | {
12 | public static function createForMedia(Media $media, string $conversionName = ''): UrlGenerator
13 | {
14 | $urlGeneratorClass = config('media-library.url_generator');
15 |
16 | static::guardAgainstInvalidUrlGenerator($urlGeneratorClass);
17 |
18 | /** @var UrlGenerator $urlGenerator */
19 | $urlGenerator = app($urlGeneratorClass);
20 |
21 | $pathGenerator = PathGeneratorFactory::create($media);
22 |
23 | $urlGenerator
24 | ->setMedia($media)
25 | ->setPathGenerator($pathGenerator);
26 |
27 | if ($conversionName !== '') {
28 | $conversion = ConversionCollection::createForMedia($media)->getByName($conversionName);
29 |
30 | $urlGenerator->setConversion($conversion);
31 | }
32 |
33 | return $urlGenerator;
34 | }
35 |
36 | public static function guardAgainstInvalidUrlGenerator(string $urlGeneratorClass): void
37 | {
38 | if (! class_exists($urlGeneratorClass)) {
39 | throw InvalidUrlGenerator::doesntExist($urlGeneratorClass);
40 | }
41 |
42 | if (! is_subclass_of($urlGeneratorClass, UrlGenerator::class)) {
43 | throw InvalidUrlGenerator::doesNotImplementUrlGenerator($urlGeneratorClass);
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------