File upload file from external file url

[MarcelWeidum]

Package

Form builder

Package Version

V3.2.92

How can we help you?

I'm trying to set the fileupload to an external file url.

This is what I tried:

Action::make('crawl')
    ->icon('heroicon-o-arrow-path')
    ->color('warning')
    ->size(ActionSize::Small)
    ->hidden(fn ($record) => !$record)
    ->requiresConfirmation()
    ->action(function($record, $livewire, Set $set) {
        $data = new Crawl('https://url-to-api')->getData();

        // Set image
        $record->image = $data['image_url'];
        $set('image', $data['image_url']);

        Storage::put('name.jpg', file_get_contents($data['image_url']);
        $local_path_to_image = Storage::get('name.jpg');
        $image = TemporaryUploadedFile::createFromLivewire($local_path_to_image);
        $set('image', [$image]);

        $record->save();
    });

[avinmaster]

+1

[denizaygundev]

@MarcelWeidum any luck? I also have this issue when importing records from an external source, I don't necessarily want to also store the images

Simplest solution I could find was to store the remote files on-the-fly, similar to your sample block.

I also ensured that the local record now uses the locally stored file (s3) instead of the completely external source.

[avinmaster]

@denizaygundev for now, I wrote such trait:

<?php

namespace App\Filament\Traits;

use App\Models\Image;
use Exception;
use Filament\Forms\Components\BaseFileUpload;
use Filament\Forms\Components\FileUpload;
use Filament\Forms\Components\Hidden;
use Filament\Forms\Set;
use Illuminate\Support\Str;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
use Storage;

/**
 * This trait handles file upload functionalities for Filament forms.
 */
trait HandlesFileUploads
{
    /**
     * The storage disk to use for file uploads.
     */
    protected static string $storageDisk = 'public';

    /**
     * Get the storage path for a specific relation.
     */
    protected static function getStoragePath(string $suffix): string
    {
        return 'images/' . Str::slug($suffix);
    }

    /**
     * Save a single uploaded file and associate it with a record.
     * @throws Exception
     */
    public static function saveUploadedFile(
        BaseFileUpload        $component,
        TemporaryUploadedFile $file,
        string                $recordNameColumn,
        string                $relationName
    ): int
    {
        $modelInstance = $component->getModelInstance();
        $suffix = $modelInstance->getTable() . ' ' . $relationName;
        $recordName = $modelInstance->$recordNameColumn ?: $modelInstance->getTable();

        $randomString = Str::random(8);
        $fileName = Str::slug($recordName . '_' . $randomString) . '.' . $file->getClientOriginalExtension();

        $directory = self::getStoragePath($suffix);

        // Ensure the directory exists
        if (!Storage::disk(self::$storageDisk)->exists($directory)) {
            Storage::disk(self::$storageDisk)->makeDirectory($directory);
        }

        // Store the file
        $path = $file->storeAs($directory, $fileName, self::$storageDisk);

        // Validate storage
        if (!$path || !Storage::disk(self::$storageDisk)->exists($path)) {
            throw new Exception("Failed to store file: $fileName");
        }

        $image = Image::create([
            'link' => $path,
            'name' => $recordName . ' ' . $suffix,
        ]);

        return $image->id;
    }

    /**
     * Create a FileUpload component for uploading a single image.
     */
    public static function imageUpload(
        string $name,
        string $label,
        string $relationship = 'icon',
        array  $acceptedFileTypes = ['image/png', 'image/jpeg', 'image/jpg', 'image/webp', 'image/gif', 'image/svg+xml'],
        string $recordTitleAttribute = null
    ): array
    {
        $recordTitleAttribute = $recordTitleAttribute ?? self::$recordTitleAttribute ?? 'name';

        return [
            FileUpload::make('rel' . $name)
                ->preserveFilenames()
                ->previewable()
                ->downloadable()
                ->label($label)
                ->image()
                ->imageEditor()
                ->live()
                ->acceptedFileTypes($acceptedFileTypes)
                ->saveUploadedFileUsing(
                    function (BaseFileUpload $component, TemporaryUploadedFile $file, Set $set) use (
                        $relationship,
                        $recordTitleAttribute,
                        $name
                    ) {
                        $imageId = self::saveUploadedFile($component, $file, $recordTitleAttribute, $relationship);
                        $set($name, $imageId);

                        $link = Image::find($imageId)?->link;
                        if ($link) {
                            $set('rel' . $name, $link);
                        }
                    }
                )
                ->deleteUploadedFileUsing(function (FileUpload $component, $state, Set $set) use ($name) {
                    $set($name, null);
                    $set('rel' . $name, null);
                    return true;
                })
                ->loadStateFromRelationshipsUsing(
                    function (BaseFileUpload $component, $record, $get) use ($name, $relationship) {
                        if ($get($name)) {
                            $link = Image::find($get($name))?->link;
                            $component->state($link);
                        } elseif ($get($name) === null && $record->$relationship) {
                            $component->state(null);
                        } elseif ($record->$relationship) {
                            $component->state($record->$relationship->link);
                        }
                    }
                )
                ->columnSpan([
                    'default' => 12,
                    'md' => 12,
                    'lg' => 12,
                ]),
            Hidden::make($name),
        ];
    }
}

In resource, you just use it like that:

...self::imageUpload(
                'avatar_image_id',
                'Avatar Image',
                'avatar'
            ),

Maybe it will help, I'm working with a related table (I have avatar_image_id instead of avatar column storing link), but I think the needed logic is here.