TenantAtlas/apps/platform/app/Filament/Concerns/ResolvesPanelTenantContext.php

<?php

declare(strict_types=1);

namespace App\Filament\Concerns;

use App\Models\ManagedEnvironment;
use App\Support\OperateHub\OperateHubShell;
use Filament\Facades\Filament;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use RuntimeException;

trait ResolvesPanelTenantContext
{
    protected static function resolveTenantContextForCurrentPanel(): ?ManagedEnvironment
    {
        $request = request();

        if (static::currentPanelId($request) === 'admin') {
            $tenant = app(OperateHubShell::class)->tenantOwnedPanelContext(request());

            if ($tenant instanceof ManagedEnvironment) {
                return $tenant;
            }

            return static::environmentFromRequestRoutePathOrReferer($request);
        }

        $tenant = static::environmentFromRequestRoutePathOrReferer($request)
            ?? ManagedEnvironment::current();

        return $tenant instanceof ManagedEnvironment ? $tenant : null;
    }

    public static function panelTenantContext(): ?ManagedEnvironment
    {
        return static::resolveTenantContextForCurrentPanel();
    }

    public static function trustedPanelTenantContext(): ?ManagedEnvironment
    {
        return static::panelTenantContext();
    }

    protected static function resolveTenantContextForCurrentPanelOrFail(): ManagedEnvironment
    {
        $tenant = static::resolveTenantContextForCurrentPanel();

        if (! $tenant instanceof ManagedEnvironment) {
            throw new RuntimeException('No tenant context selected.');
        }

        return $tenant;
    }

    protected static function resolveTrustedPanelTenantContextOrFail(): ManagedEnvironment
    {
        return static::resolveTenantContextForCurrentPanelOrFail();
    }

    private static function currentPanelId(mixed $request): ?string
    {
        $panelId = Filament::getCurrentPanel()?->getId();

        if (is_string($panelId) && $panelId !== '') {
            return $panelId;
        }

        $routeName = is_object($request) && method_exists($request, 'route')
            ? $request->route()?->getName()
            : null;

        if (is_string($routeName) && $routeName !== '') {
            if (str_contains($routeName, '.admin.')) {
                return 'admin';
            }

            if (str_contains($routeName, '.system.')) {
                return 'system';
            }
        }

        $path = is_object($request) && method_exists($request, 'path')
            ? '/'.ltrim((string) $request->path(), '/')
            : null;

        $panelId = static::panelIdFromPath($path);

        if ($panelId !== null) {
            return $panelId;
        }

        if (! $request instanceof Request || ! static::isLivewireRequest($request, $path)) {
            return null;
        }

        $refererPath = static::refererPath($request);

        return static::panelIdFromPath($refererPath);
    }

    private static function panelIdFromPath(?string $path): ?string
    {
        if (! is_string($path) || $path === '') {
            return null;
        }

        return match (true) {
            $path === '/admin', str_starts_with($path, '/admin/') => 'admin',
            $path === '/system', str_starts_with($path, '/system/') => 'system',
            default => null,
        };
    }

    private static function isLivewireRequest(Request $request, ?string $path): bool
    {
        return $request->headers->has('x-livewire')
            || (is_string($path) && preg_match('#^/(?:livewire(?:-[^/]+)?/update|livewire-unit-test-endpoint)(?:/|$)#', $path) === 1);
    }

    private static function environmentFromRequestRoutePathOrReferer(mixed $request): ?ManagedEnvironment
    {
        $routeEnvironment = is_object($request) && method_exists($request, 'route')
            ? ($request->route('environment') ?? $request->route('tenant'))
            : null;

        if ($routeEnvironment instanceof ManagedEnvironment) {
            return $routeEnvironment;
        }

        if (is_string($routeEnvironment) || is_int($routeEnvironment)) {
            $routeTenant = static::environmentFromIdentifier((string) $routeEnvironment);

            if ($routeTenant instanceof ManagedEnvironment) {
                return $routeTenant;
            }
        }

        $path = is_object($request) && method_exists($request, 'path')
            ? '/'.ltrim((string) $request->path(), '/')
            : null;

        $identifier = static::environmentIdentifierFromPath($path)
            ?? static::environmentIdentifierFromPath(static::refererPath($request));

        if (! is_string($identifier) || $identifier === '') {
            return null;
        }

        return static::environmentFromIdentifier($identifier);
    }

    private static function environmentFromIdentifier(string $identifier): ?ManagedEnvironment
    {
        if ($identifier === '') {
            return null;
        }

        return ManagedEnvironment::query()
            ->withTrashed()
            ->where(static function (Builder $query) use ($identifier): void {
                $query->where('slug', $identifier);

                if (ctype_digit($identifier)) {
                    $query->orWhereKey((int) $identifier);
                }
            })
            ->first();
    }

    private static function environmentIdentifierFromPath(?string $path): ?string
    {
        if (! is_string($path)) {
            return null;
        }

        $normalizedPath = '/'.ltrim($path, '/');

        if (preg_match('#^/admin/workspaces/[^/]+/environments/([^/]+)(?:/|$)#', $normalizedPath, $matches) !== 1) {
            return null;
        }

        $identifier = urldecode((string) $matches[1]);

        return $identifier === '' ? null : $identifier;
    }

    private static function refererPath(mixed $request): ?string
    {
        if (! is_object($request) || ! method_exists($request, 'headers')) {
            return null;
        }

        $referer = $request->headers->get('referer');

        if (! is_string($referer) || $referer === '') {
            return null;
        }

        $path = parse_url($referer, PHP_URL_PATH);

        return is_string($path) && $path !== '' ? $path : null;
    }
}