PHP code example of sierratecnologia / media-manager

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

sierratecnologia / media-manager example snippets

'providers' => [
    // ...
    MediaManager\MediaManagerProvider::class,
],

'aliases' => [
    // ...
    'MediaManager' => MediaManager\Facades\MediaManager::class,
    'FileService' => MediaManager\Services\FileService::class,
],

'disks' => [
    's3' => [
        'driver' => 's3',
        'key' => env('AWS_ACCESS_KEY_ID'),
        'secret' => env('AWS_SECRET_ACCESS_KEY'),
        'region' => env('AWS_DEFAULT_REGION'),
        'bucket' => env('AWS_BUCKET'),
    ],

    'google' => [
        'driver' => 'google',
        'clientId' => env('GOOGLE_DRIVE_CLIENT_ID'),
        'clientSecret' => env('GOOGLE_DRIVE_CLIENT_SECRET'),
        'refreshToken' => env('GOOGLE_DRIVE_REFRESH_TOKEN'),
        'folderId' => env('GOOGLE_DRIVE_FOLDER_ID'),
    ],
],

// src/Repositories/ImageRepository.php
class ImageRepository
{
    public function find($id)
    {
        return Image::find($id);
    }

    public function saveFromUpload($file, $directory = 'images')
    {
        // Lógica de persistência
    }
}

// src/Services/FileService.php
class FileService
{
    public static function saveFile($fileName, $directory = '', $fileTypes = [])
    {
        // Validação, processamento e armazenamento
    }
}

// src/Events/MediaFileAdded.php
class MediaFileAdded
{
    public $media;

    public function __construct($media)
    {
        $this->media = $media;
    }
}

// src/Observers/MediaObserver.php
class MediaObserver
{
    public function created(Media $media)
    {
        // Gerar thumbnails, processar metadata, etc.
    }
}

use MediaManager\Services\FileService;

$result = FileService::saveFile('documento', 'uploads/documentos', ['pdf', 'docx']);

// Retorna:
// [
//     'original' => 'contrato.pdf',
//     'name' => 'uploads/documentos/a3f8b9c2d1e4f5a6b7c8d9e0f1a2b3c4.pdf'
// ]

$result = FileService::saveClone('/path/to/file.jpg', 'clones/', ['jpg', 'png']);

use MediaManager\Entities\Uploads\ImageService;

$imageService = app(ImageService::class);

$image = $imageService->save(
    request()->file('imagem'),
    'produtos/',
    [
        'resize' => ['width' => 1200, 'height' => 800],
        'thumbnail' => true,
        'watermark' => true,
    ]
);

use MediaManager\Builders\ThumbnailBuilder;

$thumbnail = ThumbnailBuilder::create()
    ->forMedia($media)
    ->withDimensions(300, 200)
    ->withQuality(85)
    ->build();

use MediaManager\Services\ImagineImageProcessor;

$processor = app(ImagineImageProcessor::class);

$processedImage = $processor->resize($imagePath, 800, 600);
$croppedImage = $processor->crop($imagePath, 400, 400, 'center');
$watermarked = $processor->watermark($imagePath, $watermarkPath, 'bottom-right');

// Salvar em S3
Storage::disk('s3')->put($path, $contents);

// Salvar em Google Drive
Storage::disk('google')->put($path, $contents);

// Salvar em Dropbox
Storage::disk('dropbox')->put($path, $contents);

$localPath = 'uploads/video.mp4';
$s3Path = 'videos/video.mp4';

// Copiar de local para S3
Storage::disk('s3')->put(
    $s3Path,
    Storage::disk('local')->get($localPath)
);

use MediaManager\Services\FileService;

// URL pública protegida
$publicUrl = FileService::fileAsPublicAsset('private/documento.pdf');
// Retorna: /public-asset/eyJpdiI6IkR...

// URL de download
$downloadUrl = FileService::fileAsDownload('private/arquivo.zip', 'Arquivo.zip');
// Retorna: /public-download/eyJpdiI6...

// routes/web.php
Route::get('/public-asset/{encrypted}', [FilesController::class, 'publicAsset'])
    ->middleware(['auth', 'can:view-media']);

Route::get('/public-download/{encrypted}/{name}', [FilesController::class, 'download'])
    ->middleware(['auth', 'can:download-media']);

use MediaManager\Elements\VideoEncoder;

$encoder = new VideoEncoder();

$encoded = $encoder->encode(
    '/path/to/video.mp4',
    'outputs/encoded.mp4',
    [
        'resolution' => '1280x720',
        'bitrate' => '2000k',
        'codec' => 'h264',
    ]
);

use MediaManager\Models\Playlist;
use MediaManager\Models\Video;

$playlist = Playlist::create([
    'name' => 'Tutoriais Laravel',
    'description' => 'Série de tutoriais sobre Laravel',
    'is_public' => true,
]);

$playlist->videos()->attach([1, 2, 3, 4]);

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use MediaManager\Services\FileService;
use MediaManager\Entities\Uploads\ImageService;
use MediaManager\Models\Media;
use App\Models\Product;

class ProductController extends Controller
{
    protected $imageService;

    public function __construct(ImageService $imageService)
    {
        $this->imageService = $imageService;
    }

    public function store(Request $request)
    {
        $request->validate([
            'name' => '                   'small' => [300, 300],
                    'medium' => [600, 600],
                    'large' => [1200, 1200],
                ],
            ]
        );

        // Associar imagem ao produto
        $product->media()->attach($image->id, ['type' => 'main_image']);

        return response()->json([
            'message' => 'Produto criado com sucesso',
            'product' => $product->load('media'),
            'image_url' => $image->getUrl(),
            'thumbnails' => $image->thumbnails->map->getUrl(),
        ], 201);
    }

    public function show(Product $product)
    {
        $mainImage = $product->media()
            ->wherePivot('type', 'main_image')
            ->first();

        return view('products.show', [
            'product' => $product,
            'image' => $mainImage,
            'thumbnails' => $mainImage?->thumbnails ?? collect(),
        ]);
    }
}

use Illuminate\Support\Facades\Storage;
use MediaManager\Models\Media;

// Salvar arquivo no storage configurado
$path = Storage::disk('s3')->put('uploads', $request->file('arquivo'));

// Registrar no MediaManager
$media = Media::create([
    'disk' => 's3',
    'file_name' => basename($path),
    'mime_type' => $request->file('arquivo')->getMimeType(),
    'size' => $request->file('arquivo')->getSize(),
    'collection_name' => 'uploads',
]);

// Recuperar URL pública
$url = Storage::disk('s3')->url($media->file_name);

use MediaManager\Services\FileService;

// Em uma view Blade
$previewUrl = FileService::filePreview($media->getDiskPath());

<img src="{{ $previewUrl }}" alt="{{ $media->name }}">

// config/imagecache.php
return [
    'route' => 'imagecache',
    'path' => public_path('imagecache'),
    'lifetime' => 43200, // 30 dias
];

// Uso
<img src="{{ route('imagecache', ['template' => 'medium', 'filename' => $image->path]) }}">

// Carregar apenas quando necessário
$media = Media::find($id);
$thumbnails = $media->thumbnails()->orderBy('width')->get();

// .env
AWS_CLOUDFRONT_URL=https://d111111abcdef8.cloudfront.net

// config/filesystems.php
's3' => [
    'driver' => 's3',
    'url' => env('AWS_CLOUDFRONT_URL'),
    // ...
],

// Registrar imagem de post
$post->addMedia($request->file('featured_image'))
     ->toMediaCollection('featured');

// Recuperar
$featuredImage = $post->getFirstMedia('featured');

$product->addMultipleMediaFromRequest(['gallery'])
        ->each(fn ($fileAdder) => $fileAdder->toMediaCollection('gallery'));

$media->metadata()->create([
    'key' => 'geolocation',
    'value' => json_encode([
        'lat' => $request->latitude,
        'lng' => $request->longitude,
    ]),
]);

// Padrão de upload em qualquer microserviço
$media = app(ImageService::class)->save(
    $file,
    $directory,
    $options
);

// Garantia de consistência e reutilização

namespace App\Storage;

use League\Flysystem\Adapter\AbstractAdapter;

class CloudflareR2Adapter extends AbstractAdapter
{
    protected $client;

    public function __construct($config)
    {
        $this->client = new R2Client($config);
    }

    public function write($path, $contents, Config $config)
    {
        return $this->client->upload($path, $contents);
    }

    // Implementar outros métodos...
}

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Facades\Storage;
use App\Storage\CloudflareR2Adapter;

class CloudflareR2ServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Storage::extend('r2', function ($app, $config) {
            return new CloudflareR2Adapter($config);
        });
    }
}

'disks' => [
    'r2' => [
        'driver' => 'r2',
        'account_id' => env('R2_ACCOUNT_ID'),
        'access_key_id' => env('R2_ACCESS_KEY_ID'),
        'secret_access_key' => env('R2_SECRET_ACCESS_KEY'),
        'bucket' => env('R2_BUCKET'),
    ],
],

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\UploadedFile;

class ValidateImageDimensions
{
    public function handle($request, Closure $next)
    {
        if ($request->hasFile('image')) {
            $image = $request->file('image');

            if ($image instanceof UploadedFile) {
                [$width, $height] = getimagesize($image->path());

                if ($width < 800 || $height < 600) {
                    return response()->json([
                        'error' => 'Imagem deve ter no mínimo 800x600 pixels'
                    ], 422);
                }
            }
        }

        return $next($request);
    }
}

Route::post('/upload', [UploadController::class, 'store'])
     ->middleware(['auth', ValidateImageDimensions::class]);

namespace App\Events;

use MediaManager\Models\Media;

class ImageProcessed
{
    public $media;
    public $thumbnails;

    public function __construct(Media $media, array $thumbnails)
    {
        $this->media = $media;
        $this->thumbnails = $thumbnails;
    }
}

namespace App\Listeners;

use App\Events\ImageProcessed;
use Illuminate\Support\Facades\Cache;

class CacheImageMetadata
{
    public function handle(ImageProcessed $event)
    {
        Cache::put(
            "media:{$event->media->id}:metadata",
            [
                'thumbnails' => $event->thumbnails,
                'url' => $event->media->getUrl(),
            ],
            now()->addDays(7)
        );
    }
}

protected $listen = [
    ImageProcessed::class => [
        CacheImageMetadata::class,
        NotifyAdminOfNewImage::class,
    ],
];

namespace App\Traits;

use MediaManager\Models\Media;

trait HasGallery
{
    public function gallery()
    {
        return $this->morphMany(Media::class, 'model')
                    ->where('collection_name', 'gallery')
                    ->orderBy('order_column');
    }

    public function addToGallery($file, $order = 0)
    {
        return $this->gallery()->create([
            'file_name' => $file,
            'order_column' => $order,
        ]);
    }
}

// Uso
class Product extends Model
{
    use HasGallery;
}

$product->addToGallery($uploadedFile);

// Upload manual, sem padronização
$path = $request->file('image')->store('public/images');
$url = Storage::url($path);

// Problemas:
// - Sem thumbnails automáticos
// - Sem validação consistente
// - Sem controle de acesso
// - Difícil de escalar para S3/CDN

use MediaManager\Entities\Uploads\ImageService;

$imageService = app(ImageService::class);

$media = $imageService->save(
    $request->file('image'),
    'cms/posts/',
    [
        'thumbnail' => true,
        'sizes' => ['small' => [150, 150], 'medium' => [600, 400]],
    ]
);

$post->media()->attach($media->id);

// Benefícios:
// ✅ Thumbnails automáticos
// ✅ Validação embutida
// ✅ URLs criptografadas
// ✅ Suporte a múltiplos drivers
// ✅ Cache de imagens

namespace Market\Http\Controllers;

use Market\Models\Product;
use MediaManager\Entities\Uploads\ImageService;

class ProductImageController extends Controller
{
    public function uploadGallery(Request $request, Product $product)
    {
        $request->validate([
            'images.*' => '              'resize' => ['width' => 1500, 'height' => 1500],
                    'sizes' => [
                        'thumb' => [150, 150],
                        'catalog' => [400, 400],
                        'zoom' => [1500, 1500],
                    ],
                ]
            );

            $product->media()->attach($media->id, [
                'collection' => 'gallery',
                'order' => $index,
            ]);

            $uploadedMedia[] = $media;
        }

        return response()->json([
            'message' => 'Galeria atualizada com sucesso',
            'images' => $uploadedMedia,
        ]);
    }
}

use MediaManager\Models\File;
use MediaManager\Services\FileService;
use Tracking\Services\TrackingService;

class DocumentController extends Controller
{
    public function upload(Request $request)
    {
        $result = FileService::saveFile(
            $request->file('documento'),
            'documentos/juridico/',
            ['pdf', 'docx', 'xlsx']
        );

        $file = File::create([
            'name' => $result['original'],
            'path' => $result['name'],
            'user_id' => auth()->id(),
            'department' => 'juridico',
        ]);

        // Rastreamento com Tracking
        TrackingService::track('document.uploaded', [
            'file_id' => $file->id,
            'filename' => $result['original'],
            'user' => auth()->user()->email,
        ]);

        // URL segura de download
        $downloadUrl = FileService::fileAsDownload(
            $result['name'],
            $result['original']
        );

        return response()->json([
            'file' => $file,
            'download_url' => $downloadUrl,
        ]);
    }
}

bash
# Publicar configurações do MediaManager
php artisan vendor:publish --provider="MediaManager\MediaManagerProvider" --tag=config

# Publicar views (opcional)
php artisan vendor:publish --provider="MediaManager\MediaManagerProvider" --tag=views

# Publicar migrations
php artisan vendor:publish --provider="MediaManager\MediaManagerProvider" --tag=migrations

# Executar migrations
php artisan migrate