Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

File System

Introduuzione

Laravel offre un’astrazione potente del filesystem grazie al fantastico pacchetto PHP Flysystem di Frank de Jonge. L’integrazione di Flysystem in Laravel fornisce driver semplici per lavorare con filesystem locali, SFTP e Amazon S3. Ancora meglio, è estremamente semplice passare tra queste opzioni di archiviazione sia sulla tua macchina di sviluppo locale che sul server di produzione, poiché l’API rimane la stessa per ogni sistema.

Configurazione

Il file di configurazione del filesystem di Laravel si trova in config/filesystems.php. In questo file, puoi configurare tutti i tuoi "disk" del filesystem. Ogni disk rappresenta un driver di archiviazione specifico e una posizione di archiviazione. Nel file di configurazione sono inclusi esempi per ogni driver supportato, così puoi modificare la configurazione per riflettere le tue preferenze di archiviazione e le tue credenziali.

Il driver local interagisce con i file archiviati localmente sul server che esegue l’applicazione Laravel, mentre il driver s3 viene utilizzato per scrivere nel servizio di archiviazione cloud S3 di Amazon.

Puoi configurare quanti disk desideri e puoi anche avere più disk che utilizzano lo stesso driver.

Il Driver Locale

Quando usi il driver local, tutte le operazioni sui file sono relative alla directory root definita nel tuo file di configurazione filesystems. Per impostazione predefinita, questo valore è impostato sulla directory storage/app. Pertanto, il seguente metodo scriverebbe su storage/app/example.txt:

use Illuminate\Support\Facades\Storage;

Storage::disk('local')->put('example.txt', 'Contents');

Il Public Disk

Il disk public incluso nel file di configurazione filesystems della tua applicazione è pensato per i file che saranno accessibili pubblicamente. Per impostazione predefinita, il disk public utilizza il driver local e memorizza i file in storage/app/public.

Per rendere questi file accessibili dal web, dovresti creare un link simbolico dalla directory di origine storage/app/public alla directory di destinazione public/storage. Utilizzare questa convenzione delle cartelle manterrà i tuoi file accessibili pubblicamente in una sola directory che può essere facilmente condivisa tra i deployment quando si utilizzano sistemi di deployment a zero downtime come Envoyer.

Per creare il link simbolico, puoi usare il comando Artisan storage:link:

php artisan storage:link

Una volta che un file è stato memorizzato e il link simbolico è stato creato, puoi creare un URL per i file usando l’helper asset:

    echo asset('storage/file.txt');

Puoi configurare link simbolici aggiuntivi nel tuo file di configurazione filesystems. Ciascuno dei link configurati verrà creato quando esegui il comando storage:link:

    'links' => [
        public_path('storage') => storage_path('app/public'),
        public_path('images') => storage_path('app/images'),
    ],

Il comando storage:unlink può essere usato per distruggere i tuoi link simbolici configurati:

php artisan storage:unlink

Prerequisiti del Driver

Configurazione del Driver S3

Prima di usare il driver S3, devi installare il pacchetto Flysystem S3 tramite il gestore di pacchetti Composer:

composer require league/flysystem-aws-s3-v3 "^3.0" --with-all-dependencies

Un array di configurazione per il disk S3 si trova nel file config/filesystems.php. Solitamente, devi configurare le tue informazioni e credenziali S3 usando le seguenti variabili d’ambiente, che vengono richiamate dal file config/filesystems.php:

AWS_ACCESS_KEY_ID=<your-key-id>
AWS_SECRET_ACCESS_KEY=<your-secret-access-key>
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=<your-bucket-name>
AWS_USE_PATH_STYLE_ENDPOINT=false

Per comodità, queste variabili d’ambiente seguono la convenzione di denominazione usata dall’AWS CLI.

Configurazione del Driver FTP

Prima di usare il driver FTP, devi installare il pacchetto Flysystem FTP tramite il gestore di pacchetti Composer:

composer require league/flysystem-ftp "^3.0"

Le integrazioni Flysystem di Laravel funzionano bene con FTP; tuttavia, una configurazione di esempio non è inclusa nel file di configurazione predefinito config/filesystems.php del framework. Se devi configurare un filesystem FTP, puoi usare l’esempio di configurazione seguente:

    'ftp' => [
        'driver' => 'ftp',
        'host' => env('FTP_HOST'),
        'username' => env('FTP_USERNAME'),
        'password' => env('FTP_PASSWORD'),

        // Impostazioni FTP Opzionali...
        // 'port' => env('FTP_PORT', 21),
        // 'root' => env('FTP_ROOT'),
        // 'passive' => true,
        // 'ssl' => true,
        // 'timeout' => 30,
    ],

Configurazione del Driver SFTP

Prima di utilizzare il driver SFTP, devi installare il pacchetto Flysystem SFTP tramite il gestore di pacchetti Composer:

composer require league/flysystem-sftp-v3 "^3.0"

Le integrazioni Flysystem di Laravel funzionano bene con SFTP; tuttavia, una configurazione di esempio non è inclusa nel file di configurazione predefinito config/filesystems.php del framework. Se hai bisogno di configurare un filesystem SFTP, puoi utilizzare l’esempio di configurazione seguente:

    'sftp' => [
        'driver' => 'sftp',
        'host' => env('SFTP_HOST'),

        // Impostazioni per l'autenticazione base...
        'username' => env('SFTP_USERNAME'),
        'password' => env('SFTP_PASSWORD'),

        // Impostazioni per l'autenticazione basata su chiave SSH con password di crittografia...
        'privateKey' => env('SFTP_PRIVATE_KEY'),
        'passphrase' => env('SFTP_PASSPHRASE'),

        // Impostazioni per i permessi di file / directory...
        'visibility' => 'private', // `private` = 0600, `public` = 0644
        'directory_visibility' => 'private', // `private` = 0700, `public` = 0755

        // Impostazioni SFTP opzionali...
        // 'hostFingerprint' => env('SFTP_HOST_FINGERPRINT'),
        // 'maxTries' => 4,
        // 'passphrase' => env('SFTP_PASSPHRASE'),
        // 'port' => env('SFTP_PORT', 22),
        // 'root' => env('SFTP_ROOT', ''),
        // 'timeout' => 30,
        // 'useAgent' => true,
    ],

Filesystem Scoped e Sola Lettura

I disk scoped ti permettono di definire un filesystem in cui tutti i percorsi sono automaticamente prefissati con un determinato prefisso. Prima di creare un disk filesystem scoped, devi installare un pacchetto Flysystem aggiuntivo tramite il gestore di pacchetti Composer:

composer require league/flysystem-path-prefixing "^3.0"

Puoi creare un’istanza scoped di percorso di qualsiasi disk filesystem esistente definendo un disk che utilizza il driver scoped. Ad esempio, puoi creare un disk che applica un prefisso di percorso specifico al tuo disk s3 esistente, e così ogni operazione sui file usando il tuo disk scoped utilizzerà il prefisso specificato:

's3-videos' => [
    'driver' => 'scoped',
    'disk' => 's3',
    'prefix' => 'path/to/videos',
],

I disk "Sola Lettura" ti permettono di creare disk filesystem che non consentono operazioni di scrittura. Prima di usare l’opzione di configurazione read-only, devi installare un pacchetto Flysystem aggiuntivo tramite il gestore di pacchetti Composer:

composer require league/flysystem-read-only "^3.0"

Successivamente, puoi includere l’opzione di configurazione read-only in una o più delle configurazioni dei tuoi disk:

's3-videos' => [
    'driver' => 's3',
    // ...
    'read-only' => true,
],

Filesystem compatibili con Amazon S3

Per impostazione predefinita, il file di configurazione filesystems della tua applicazione contiene una configurazione per il disk s3. Oltre a usare questo disk per interagire con Amazon S3, puoi utilizzarlo per interagire con qualsiasi servizio di archiviazione file compatibile S3 come MinIO o DigitalOcean Spaces.

Di solito, dopo aver aggiornato le credenziali del disk per corrispondere a quelle del servizio che intendi utilizzare, devi solo aggiornare il valore dell’opzione di configurazione endpoint. Il valore di questa opzione è generalmente definito tramite la variabile d’ambiente AWS_ENDPOINT:

    'endpoint' => env('AWS_ENDPOINT', 'https://minio:9000'),

MinIO

Per fare in modo che l’integrazione Flysystem di Laravel generi URL corretti usando MinIO, definisci la variabile d’ambiente AWS_URL in modo che corrisponda all’URL locale dell’applicazione e includa il nome del bucket nel percorso URL:

AWS_URL=http://localhost:9000/local

La generazione di URL temporanei per lo storage tramite il metodo temporaryUrl potrebbe non funzionare quando si utilizza MinIO se l’endpoint non è accessibile dal client.

Ottenere le istanze dei disk

La facciata Storage può essere utilizzata per interagire con qualsiasi dei disk configurati. Ad esempio, puoi usare il metodo put sulla facciata per memorizzare un avatar sul disk predefinito. Se chiami i metodi sulla facciata Storage senza prima utilizzare il metodo disk, il metodo verrà automaticamente indirizzato al disk predefinito:

use Illuminate\Support\Facades\Storage;

Storage::put('avatars/1', $content);

Se la tua applicazione interagisce con più disk, puoi utilizzare il metodo disk sulla facciata Storage per lavorare con i file su un disk specifico:

Storage::disk('s3')->put('avatars/1', $content);

Disk su Richiesta

A volte potresti voler creare un disk durante l’esecuzione utilizzando una configurazione specifica senza che questa configurazione sia presente nel file di configurazione filesystems della tua applicazione. Per fare ciò, puoi passare un array di configurazione al metodo build della facade Storage:

use Illuminate\Support\Facades\Storage;

$disk = Storage::build([
    'driver' => 'local',
    'root' => '/path/to/root',
]);

$disk->put('image.jpg', $content);

Leggere File

Il metodo get può essere utilizzato per recuperare il contenuto di un file. Il contenuto del file verrà restituito come stringa grezza dal metodo. Ricorda, tutti i percorsi dei file dovrebbero essere specificati relativi alla posizione "root" del disk:

$contents = Storage::get('file.jpg');

Se il file che stai recuperando contiene JSON, puoi usare il metodo json per ottenere il file e decodificare il suo contenuto:

$orders = Storage::json('orders.json');

Il metodo exists può essere usato per verificare se un file esiste sul disk:

if (Storage::disk('s3')->exists('file.jpg')) {
    // ...
}

Il metodo missing può essere usato per verificare se un file manca sul disk:

if (Storage::disk('s3')->missing('file.jpg')) {
    // ...
}

Scaricare File

Il metodo download può essere utilizzato per generare una risposta che forza il browser dell’utente a scaricare il file nel percorso specificato. Il metodo download accetta un nome file come secondo argomento, che determinerà il nome del file visualizzato dall’utente durante il download. Infine, puoi passare un array di header HTTP come terzo argomento al metodo:

return Storage::download('file.jpg');

return Storage::download('file.jpg', $name, $headers);

URL dei File

Puoi usare il metodo url per ottenere l’URL di un determinato file. Se usi il driver local, solitamente aggiungerà /storage al percorso specificato e restituirà un URL relativo al file. Se usi il driver s3, verrà restituito l’URL remoto completamente qualificato:

use Illuminate\Support\Facades\Storage;

$url = Storage::url('file.jpg');

Quando usi il driver local, tutti i file che devono essere accessibili pubblicamente devono essere posizionati nella directory storage/app/public. Inoltre, dovresti creare un link simbolico in public/storage che punta alla directory storage/app/public.

Quando usi il driver local, il valore restituito da url non è codificato in URL. Per questo motivo, consigliamo di memorizzare i file utilizzando sempre nomi che creino URL validi.

Personalizzazione dell’Host URL

Se desideri modificare l’host per gli URL generati utilizzando la facade Storage, puoi aggiungere o modificare l’opzione url nell’array di configurazione del disk:

'public' => [
    'driver' => 'local',
    'root' => storage_path('app/public'),
    'url' => env('APP_URL').'/storage',
    'visibility' => 'public',
    'throw' => false,
],

URL Temporanee

Con il metodo temporaryUrl, puoi creare URL temporanee per i file archiviati utilizzando i driver local e s3. Questo metodo accetta un percorso e un’istanza di DateTime che indica quando l’URL deve scadere:

use Illuminate\Support\Facades\Storage;

$url = Storage::temporaryUrl(
    'file.jpg', now()->addMinutes(5)
);

Abilitare gli URL Temporanei Locali

Se hai iniziato a sviluppare la tua applicazione prima che il supporto per gli URL temporanei venisse introdotto nel driver local, potresti dover abilitare gli URL temporanei locali. Per farlo, aggiungi l’opzione serve all’array di configurazione del tuo disk local nel file di configurazione config/filesystems.php:

'local' => [
    'driver' => 'local',
    'root' => storage_path('app/private'),
    'serve' => true, // [tl! add]
    'throw' => false,
],

Parametri della Richiesta S3

Se hai bisogno di specificare parametri aggiuntivi della richiesta S3, puoi passare l’array di parametri della richiesta come terzo argomento al metodo temporaryUrl:

$url = Storage::temporaryUrl(
    'file.jpg',
    now()->addMinutes(5),
    [
        'ResponseContentType' => 'application/octet-stream',
        'ResponseContentDisposition' => 'attachment; filename=file2.jpg',
    ]
);

Personalizzare gli URL temporanei

Se hai bisogno di personalizzare come vengono creati gli URL temporanei per un disk di archiviazione specifico, puoi usare il metodo buildTemporaryUrlsUsing. Ad esempio, questo può essere utile se hai un controller che permette di scaricare file memorizzati tramite un disk che di solito non supporta gli URL temporanei. Di solito, questo metodo dovrebbe essere chiamato dal metodo boot di un service provider:

<?php

namespace App\Providers;

use DateTime;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\URL;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap qualsiasi servizio dell'applicazione.
     */
    public function boot(): void
    {
        Storage::disk('local')->buildTemporaryUrlsUsing(
            function (string $path, DateTime $expiration, array $options) {
                return URL::temporarySignedRoute(
                    'files.download',
                    $expiration,
                    array_merge($options, ['path' => $path])
                );
            }
        );
    }
}

Upload URLs Temporanei

La possibilità di generare URL temporanee per l’upload è supportata solo dal driver s3.

Se hai bisogno di generare un URL temporaneo che può essere utilizzato per caricare un file direttamente dalla tua applicazione lato client, puoi usare il metodo temporaryUploadUrl. Questo metodo accetta un percorso e un’istanza di DateTime che specifica quando l’URL deve scadere. Il metodo temporaryUploadUrl restituisce un array associativo che può essere suddiviso nell’URL di upload e negli header che devono essere inclusi nella richiesta di upload:

use Illuminate\Support\Facades\Storage;

['url' => $url, 'headers' => $headers] = Storage::temporaryUploadUrl(
    'file.jpg', now()->addMinutes(5)
);

Questo metodo è principalmente utile in ambienti serverless che richiedono che l’applicazione lato client carichi direttamente i file su un sistema di archiviazione cloud come Amazon S3.

Metadati del File

Oltre alla lettura e alla scrittura dei file, Laravel può anche fornire informazioni sui file stessi. Ad esempio, il metodo size può essere utilizzato per ottenere la dimensione di un file in byte:

use Illuminate\Support\Facades\Storage;

$size = Storage::size('file.jpg');

Il metodo lastModified restituisce il timestamp UNIX dell’ultima modifica del file:

$time = Storage::lastModified('file.jpg');

Il tipo MIME di un determinato file può essere ottenuto tramite il metodo mimeType:

$mime = Storage::mimeType('file.jpg');

Percorsi dei File

Puoi utilizzare il metodo path per ottenere il percorso di un determinato file. Se utilizzi il driver local, questo restituirà il percorso assoluto del file. Se utilizzi il driver s3, questo metodo restituirà il percorso relativo del file nel bucket S3:

    use Illuminate\Support\Facades\Storage;

    $path = Storage::path('file.jpg');

Salvataggio dei File

Il metodo put può essere utilizzato per salvare il contenuto dei file su un disk. Puoi anche passare una resource PHP al metodo put, che utilizzerà il supporto stream di Flysystem. Ricorda che tutti i percorsi dei file devono essere specificati in relazione alla posizione "root" configurata per il disk:

use Illuminate\Support\Facades\Storage;

Storage::put('file.jpg', $contents);

Storage::put('file.jpg', $resource);

Fallimento dei Salvataggi

Se il metodo put (o altre operazioni di "scrittura") non riesce a scrivere il file sul disk, verrà restituito false:

if (! Storage::put('file.jpg', $contents)) {
    // Il file non è stato possibile scrivere sul disk...
}

Se desideri, puoi definire l’opzione throw nell’array di configurazione del tuo filesystem disk. Quando questa opzione è impostata su true, i metodi di "scrittura" come put lanceranno un’istanza di League\Flysystem\UnableToWriteFile quando le operazioni di scrittura falliscono:

'public' => [
    'driver' => 'local',
    // ...
    'throw' => true,
],

Scrivere all’inizio e alla fine dei file

I metodi prepend e append consentono di scrivere all’inizio o alla fine di un file:

    Storage::prepend('file.log', 'Testo aggiunto all\'inizio');

    Storage::append('file.log', 'Testo aggiunto alla fine');

Copiare e Spostare File

Il metodo copy può essere usato per copiare un file esistente in una nuova posizione sul disk, mentre il metodo move può essere utilizzato per rinominare o spostare un file esistente in una nuova posizione:

Storage::copy('old/file.jpg', 'new/file.jpg');

Storage::move('old/file.jpg', 'new/file.jpg');

Streaming Automatico

Trasmettere file allo storage riduce significativamente l’uso della memoria. Se desideri che Laravel gestisca automaticamente il trasferimento di un determinato file nella tua posizione di storage, puoi utilizzare il metodo putFile o putFileAs. Questo metodo accetta un’istanza di Illuminate\Http\File o Illuminate\Http\UploadedFile e trasmetterà automaticamente il file nella posizione desiderata:

use Illuminate\Http\File;
use Illuminate\Support\Facades\Storage;

// Genera automaticamente un ID univoco per il nome del file...
$path = Storage::putFile('photos', new File('/path/to/photo'));

// Specifica manualmente un nome del file...
$path = Storage::putFileAs('photos', new File('/path/to/photo'), 'photo.jpg');

Ci sono alcune cose importanti da notare sul metodo putFile. Nota che abbiamo specificato solo il nome della directory e non un nome del file. Per impostazione predefinita, il metodo putFile genererà un ID univoco come nome del file. L’estensione del file sarà determinata esaminando il tipo MIME del file. Il percorso del file verrà restituito dal metodo putFile in modo da poter memorizzare il percorso, incluso il nome del file generato, nel tuo database.

I metodi putFile e putFileAs accettano anche un argomento per specificare la "visibilità" del file memorizzato. Questo è particolarmente utile se stai archiviando il file su un disk cloud come Amazon S3 e desideri che il file sia accessibile pubblicamente tramite URL generate:

Storage::putFile('photos', new File('/path/to/photo'), 'public');

Caricamento di File

Nelle applicazioni web, uno degli usi più comuni per la memorizzazione dei file è archiviare file caricati dagli utenti come foto e documenti. Laravel rende molto semplice memorizzare file caricati usando il metodo store su un’istanza di file caricato. Chiama il metodo store con il percorso in cui desideri memorizzare il file caricato:

    <?php

    namespace App\Http\Controllers;

    use App\Http\Controllers\Controller;
    use Illuminate\Http\Request;

    class UserAvatarController extends Controller
    {
        /**
         * Aggiorna l'avatar per l'utente.
         */
        public function update(Request $request): string
        {
            $path = $request->file('avatar')->store('avatars');

            return $path;
        }
    }

Ci sono alcune cose importanti da notare in questo esempio. Nota che abbiamo specificato solo il nome di una directory, non un nome di file. Di default, il metodo store genererà un ID unico da usare come nome del file. L’estensione del file sarà determinata esaminando il tipo MIME del file. Il percorso del file sarà restituito dal metodo store così puoi memorizzare il percorso, incluso il nome del file generato, nel tuo database.

Puoi anche chiamare il metodo putFile sulla facade Storage per eseguire la stessa operazione di memorizzazione del file come nell’esempio sopra:

    $path = Storage::putFile('avatars', $request->file('avatar'));

Specificare un Nome del File

Se non vuoi che un nome file venga assegnato automaticamente al tuo file memorizzato, puoi utilizzare il metodo storeAs, che riceve il percorso, il nome del file e (opzionale) il disk come argomenti:

    $path = $request->file('avatar')->storeAs(
        'avatars', $request->user()->id
    );

Puoi anche utilizzare il metodo putFileAs sulla facade Storage, che eseguirà la stessa operazione di memorizzazione del file come nell’esempio precedente:

    $path = Storage::putFileAs(
        'avatars', $request->file('avatar'), $request->user()->id
    );

I caratteri Unicode non stampabili e invalidi verranno rimossi automaticamente dai percorsi dei file. Pertanto, potresti voler sanificare i percorsi dei file prima di passarli ai metodi di storage di Laravel. I percorsi dei file sono normalizzati usando il metodo League\Flysystem\WhitespacePathNormalizer::normalizePath.

Specificare un Disk

Per impostazione predefinita, il metodo store di questo file caricato utilizzerà il disk predefinito. Se desideri specificare un altro disk, passa il nome del disk come secondo argomento al metodo store:

$path = $request->file('avatar')->store(
    'avatars/'.$request->user()->id, 's3'
);

Se stai utilizzando il metodo storeAs, puoi passare il nome del disk come terzo argomento al metodo:

$path = $request->file('avatar')->storeAs(
    'avatars',
    $request->user()->id,
    's3'
);

Altre Informazioni sul File Caricato

Se desideri ottenere il nome originale e l’estensione del file caricato, puoi farlo utilizzando i metodi getClientOriginalName e getClientOriginalExtension:

$file = $request->file('avatar');

$name = $file->getClientOriginalName();
$extension = $file->getClientOriginalExtension();

Tuttavia, tieni presente che i metodi getClientOriginalName e getClientOriginalExtension sono considerati non sicuri, poiché il nome e l’estensione del file potrebbero essere manomessi da un utente malintenzionato. Per questo motivo, di solito è meglio preferire i metodi hashName ed extension per ottenere un nome e un’estensione per il file caricato:

$file = $request->file('avatar');

$name = $file->hashName(); // Genera un nome unico e casuale...
$extension = $file->extension(); // Determina l'estensione del file basandosi sul tipo MIME...

Visibilità dei File

Nell’integrazione Flysystem di Laravel, la "visibilità" è un’astrazione delle autorizzazioni dei file su più piattaforme. I file possono essere dichiarati public o private. Quando un file è dichiarato public, indichi che il file dovrebbe essere generalmente accessibile ad altri. Ad esempio, quando si utilizza il driver S3, puoi recuperare gli URL per i file public.

Puoi impostare la visibilità quando scrivi il file tramite il metodo put:

use Illuminate\Support\Facades\Storage;

Storage::put('file.jpg', $contents, 'public');

Se il file è già stato memorizzato, la sua visibilità può essere recuperata e impostata tramite i metodi getVisibility e setVisibility:

$visibility = Storage::getVisibility('file.jpg');

Storage::setVisibility('file.jpg', 'public');

Quando interagisci con file caricati, puoi utilizzare i metodi storePublicly e storePubliclyAs per memorizzare il file caricato con visibilità public:

$path = $request->file('avatar')->storePublicly('avatars', 's3');

$path = $request->file('avatar')->storePubliclyAs(
    'avatars',
    $request->user()->id,
    's3'
);

File locali e Visibilità

Quando usi il driver local, la visibilità public corrisponde a permessi 0755 per le directory e 0644 per i file. Puoi modificare le mappature dei permessi nel file di configurazione filesystems della tua applicazione:

'local' => [
    'driver' => 'local',
    'root' => storage_path('app'),
    'permissions' => [
        'file' => [
            'public' => 0644,
            'private' => 0600,
        ],
        'dir' => [
            'public' => 0755,
            'private' => 0700,
        ],
    ],
    'throw' => false,
],

Eliminazione dei File

Il metodo delete accetta un singolo nome di file o un array di file da eliminare:

use Illuminate\Support\Facades\Storage;

Storage::delete('file.jpg');

Storage::delete(['file.jpg', 'file2.jpg']);

Se necessario, puoi specificare il disk da cui eliminare il file:

use Illuminate\Support\Facades\Storage;

Storage::disk('s3')->delete('path/file.jpg');

Directory

Ottenere Tutti i File All’interno di una Directory

Il metodo files restituisce un array di tutti i file in una determinata directory. Se desideri ottenere un elenco di tutti i file all’interno di una directory, comprese tutte le sottodirectory, puoi usare il metodo allFiles:

use Illuminate\Support\Facades\Storage;

$files = Storage::files($directory);

$files = Storage::allFiles($directory);

Ottenere tutte le directory all’interno di una directory

Il metodo directories restituisce un array con tutte le directory presenti in una directory specificata. Inoltre, puoi usare il metodo allDirectories per ottenere un elenco di tutte le directory all’interno della directory specificata e di tutte le sue sottodirectory:

$directories = Storage::directories($directory);

$directories = Storage::allDirectories($directory);

Creare una Directory

Il metodo makeDirectory creerà la directory specificata, inclusi eventuali sottodirectory necessarie:

Storage::makeDirectory($directory);

Eliminare una Directory

Infine, il metodo deleteDirectory può essere utilizzato per rimuovere una directory e tutti i suoi file:

    Storage::deleteDirectory($directory);

Test

Il metodo fake della facade Storage ti permette di generare facilmente un disk fittizio che, combinato con le utility di generazione file della classe Illuminate\Http\UploadedFile, semplifica notevolmente i test di caricamento dei file. Ad esempio:

<?php

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

test('albums can be uploaded', function () {
    Storage::fake('photos');

    $response = $this->json('POST', '/photos', [
        UploadedFile::fake()->image('photo1.jpg'),
        UploadedFile::fake()->image('photo2.jpg')
    ]);

    // Verifica che uno o più file siano stati memorizzati...
    Storage::disk('photos')->assertExists('photo1.jpg');
    Storage::disk('photos')->assertExists(['photo1.jpg', 'photo2.jpg']);

    // Verifica che uno o più file non siano stati memorizzati...
    Storage::disk('photos')->assertMissing('missing.jpg');
    Storage::disk('photos')->assertMissing(['missing.jpg', 'non-existing.jpg']);

    // Verifica che il numero di file in una directory data corrisponda al conteggio previsto...
    Storage::disk('photos')->assertCount('/wallpapers', 2);

    // Verifica che una directory data sia vuota...
    Storage::disk('photos')->assertDirectoryEmpty('/wallpapers');
});

<?php

namespace Tests\Feature;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_albums_can_be_uploaded(): void
    {
        Storage::fake('photos');

        $response = $this->json('POST', '/photos', [
            UploadedFile::fake()->image('photo1.jpg'),
            UploadedFile::fake()->image('photo2.jpg')
        ]);

        // Verifica che uno o più file siano stati memorizzati...
        Storage::disk('photos')->assertExists('photo1.jpg');
        Storage::disk('photos')->assertExists(['photo1.jpg', 'photo2.jpg']);

        // Verifica che uno o più file non siano stati memorizzati...
        Storage::disk('photos')->assertMissing('missing.jpg');
        Storage::disk('photos')->assertMissing(['missing.jpg', 'non-existing.jpg']);

        // Verifica che il numero di file in una directory data corrisponda al conteggio previsto...
        Storage::disk('photos')->assertCount('/wallpapers', 2);

        // Verifica che una directory data sia vuota...
        Storage::disk('photos')->assertDirectoryEmpty('/wallpapers');
    }
}

Per impostazione predefinita, il metodo fake eliminerà tutti i file nella sua directory temporanea. Se desideri conservare questi file, puoi utilizzare invece il metodo persistentFake. Per ulteriori informazioni sui test di caricamento dei file, puoi consultare le informazioni sul caricamento dei file nella documentazione dei test HTTP.

Il metodo image richiede l’estensione GD.

Filesystem Personalizzati

L’integrazione di Flysystem in Laravel supporta diversi "driver" di default; tuttavia, Flysystem non si limita a questi e dispone di adattatori per molti altri sistemi di archiviazione. Puoi creare un driver personalizzato se desideri utilizzare uno di questi adattatori aggiuntivi nella tua applicazione Laravel.

Per definire un filesystem personalizzato, avrai bisogno di un adattatore Flysystem. Aggiungiamo un adattatore Dropbox mantenuto dalla community al nostro progetto:

composer require spatie/flysystem-dropbox

Successivamente, puoi registrare il driver all’interno del metodo boot di uno dei service providers della tua applicazione. Per fare ciò, dovresti usare il metodo extend della facade Storage:

    <?php

    namespace App\Providers;

    use Illuminate\Contracts\Foundation\Application;
    use Illuminate\Filesystem\FilesystemAdapter;
    use Illuminate\Support\Facades\Storage;
    use Illuminate\Support\ServiceProvider;
    use League\Flysystem\Filesystem;
    use Spatie\Dropbox\Client as DropboxClient;
    use Spatie\FlysystemDropbox\DropboxAdapter;

    class AppServiceProvider extends ServiceProvider
    {
        /**
         * Registra eventuali servizi dell'applicazione.
         */
        public function register(): void
        {
            // ...
        }

        /**
         * Bootstrap di eventuali servizi dell'applicazione.
         */
        public function boot(): void
        {
            Storage::extend('dropbox', function (Application $app, array $config) {
                $adapter = new DropboxAdapter(new DropboxClient(
                    $config['authorization_token']
                ));

                return new FilesystemAdapter(
                    new Filesystem($adapter, $config),
                    $adapter,
                    $config
                );
            });
        }
    }

Il primo argomento del metodo extend è il nome del driver e il secondo è una closure che riceve le variabili $app e $config. La closure deve restituire un’istanza di Illuminate\Filesystem\FilesystemAdapter. La variabile $config contiene i valori definiti in config/filesystems.php per il disk specificato.

Una volta creato e registrato il service provider dell’estensione, puoi usare il driver dropbox nel tuo file di configurazione config/filesystems.php.

Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia