namespace App\Services;

use HeadlessChromium\BrowserFactory;

class HtmlToPdfConverter
{
    /**
     * Render a PDF from the given HTML.
     */
    public static function render(string $html): string
    {
        $browser = (new BrowserFactory())->createBrowser([
            'windowSize' => [1920, 1080]
        ]);

        $page = $browser->createPage();

        $page->setHtml($html);

        return base64_decode(
            $page->pdf([
                'printBackground' => true
            ])->getBase64()
        );
    }
}

use App\Services\HtmlToPdfConverter;

Route::get('/html-to-pdf', function () {
    $pdf = HtmlToPdfConverter::render('<h1>Hello World</h1>');

    return response($pdf, 200, [
        'Content-Type' => 'application/pdf',
        'Content-Disposition' => 'inline; filename="hello.pdf"'
    ]);
});

protected function complexStats(): Attribute
{
    return Attribute::make(
        get: fn () => $this->calculateStats()
    )->shouldCache();
}

<?php
 
namespace App\Models;
 
use App\ValueObjects\Location;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Casts\Attribute;
 
class Store extends Model
{
    protected function location(): Attribute
    {
        return Attribute::make(
            get: fn ($value) => new Location(
                latitude: $this->latitude,
                longitude: $this->longitude,
                address: $this->address,
                timezone: $this->timezone
            ),
            set: function (Location $location) {
                return [
                    'latitude' => $location->latitude,
                    'longitude' => $location->longitude,
                    'address' => $location->address,
                    'timezone' => $location->timezone
                ];
            }
        )->shouldCache();
    }
 
    protected function operatingHours(): Attribute
    {
        return Attribute::make(
            get: fn () => $this->calculateHours()
        )->withoutObjectCaching();
    }
 
    private function calculateHours()
    {
        // Dynamic calculation based on timezone and current time
        return $this->location->getLocalHours();
    }
}

$store = Store::find(1);
$store->location->address = '123 New Street';
$store->save();
 
// Access operating hours (recalculated each time)
$hours = $store->operatingHours;

use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
 
// Basic validation
$validator = Validator::make($request->all(), [
    'profile_photo' => [
        'required',
        Rule::dimensions()
            ->minWidth(400)
            ->minHeight(400)
            ->maxWidth(2000)
            ->maxHeight(2000)
    ]
]

class MediaController extends Controller
{
    public function upload(Request $request)
    {
        $imageType = $request->input('type', 'standard');
 
        $rules = [
            'image' => array_merge(
                ['required', 'image', 'max:10240'], // 10MB max
                $this->getDimensionRules($imageType)
            )
        ];
 
        $request->validate($rules);
 
        // Process and store the validated image
        $path = $request->file('image')->store('media/' . $imageType);
 
        return response()->json([
            'success' => true,
            'path' => $path
        ]);
    }
 
    protected function getDimensionRules(string $type): array
    {
        return match($type) {
            'thumbnail' => [
                Rule::dimensions()
                    ->width(300)
                    ->height(300)
            ],
            'hero' => [
                Rule::dimensions()
                    ->minWidth(1200)
                    ->minHeight(600)
                    ->maxHeight(800)
                    ->ratio(2)
            ],
            'gallery' => [
                Rule::dimensions()
                    ->minWidth(800)
                    ->minHeight(600)
                    ->maxWidth(3000)
                    ->maxHeight(2000)
            ],
            default => [
                Rule::dimensions()
                    ->minWidth(400)
                    ->minHeight(400)
            ]
        };
    }
}

Route::fallback(function () {
    return view('errors.404')
        ->with('message', 'Page not found');
});

use Illuminate\Http\Request;
 
Route::fallback(function (Request $request) {
    // Access current path
    $path = $request->path();
 
    // Check if it's an API request
    if ($request->expectsJson()) {
        return response()->json(['error' => 'Not Found'], 404);
    }
 
    return view('errors.404', compact('path'));
});

<?php
 
namespace App\Http\Middleware;
 
use Closure;
use Illuminate\Http\Request;
use Firebase\JWT\JWT;
use Firebase\JWT\SignatureInvalidException;
use Firebase\JWT\BeforeValidException;
use Firebase\JWT\ExpiredException;
use DomainException;
use InvalidArgumentException;
use UnexpectedValueException;
 
class JsonWebTokenAuthentication
{
    public function handle(Request $request, Closure $next)
    {
        $bearerToken = $request->bearerToken() ?? '';
        $key = config('PATH_TO_YOUR_KEY');
 
        try {
            $decoded = JWT::decode($bearerToken, $key);
        } catch (InvalidArgumentException $e) {
            // provided key/key-array is empty or malformed.
        } catch (DomainException $e) {
            // provided algorithm is unsupported OR
            // provided key is invalid OR
            // unknown error thrown in openSSL or libsodium OR
            // libsodium is required but not available.
        } catch (SignatureInvalidException $e) {
            // provided JWT signature verification failed.
        } catch (BeforeValidException $e) {
            // provided JWT is trying to be used before "nbf" claim OR
            // provided JWT is trying to be used before "iat" claim.
        } catch (ExpiredException $e) {
            // provided JWT is trying to be used after "exp" claim.
        } catch (UnexpectedValueException $e) {
            // provided JWT is malformed OR
            // provided JWT is missing an algorithm / using an unsupported algorithm OR
            // provided JWT algorithm does not match provided key OR
            // provided key ID in key/key-array is empty or invalid.
        }
 
        return $next($request);
    }
}

<form method="POST" action="...">

@honeypot

<input type="text" name="my_normal_input" value="">

...

</form>

use Spatie\Honeypot\ProtectAgainstSpam;

Route::middleware(ProtectAgainstSpam::class)->group(function() {

// Routes protected with honeypot technique

});

// app/bootstrap/app.php

->withMiddleware(function (Middleware $middleware): void {  
    $middleware->append(\Spatie\Honeypot\ProtectAgainstSpam::class);  
})

<?php

namespace App\Filament\Dashboard\Pages\Auth;

use Illuminate\Http\RedirectResponse;
use Livewire\Features\SupportRedirects\Redirector;
use Filament\Auth\Http\Responses\Contracts\LoginResponse as LoginResponseContract;

class LoginResponse implements LoginResponseContract
{
    public function toResponse($request): RedirectResponse|Redirector
    {
        if (session()->has('intended_url')) {
            $intendedUrl = session()->pull('intended_url');
            return redirect()->to($intendedUrl);
        }

        return redirect()->intended(filament()->getUrl());
    }
}

<?php

namespace App\Filament\Dashboard\Pages\Auth;

use Illuminate\Http\RedirectResponse;
use Filament\Auth\Http\Responses\Contracts\LogoutResponse as Responsable;

class LogoutResponse implements Responsable
{
    public function toResponse($request): RedirectResponse
    {
        return redirect()->route('home');
    }
}

use App\Filament\Dashboard\Pages\Auth\LoginResponse;
use App\Filament\Dashboard\Pages\Auth\LogoutResponse;
use Filament\Auth\Http\Responses\Contracts\LoginResponse as LoginResponseContract;
use Filament\Auth\Http\Responses\Contracts\LogoutResponse as LogoutResponseContract;

public function register(): void
{
    $this->app->bind(LogoutResponseContract::class, LogoutResponse::class);
    $this->app->bind(LoginResponseContract::class, LoginResponse::class);
}