Skip to content

Beautiful Open-Source Form Builder

8.6 KB
Raw Blame
<?php

namespace App\Service\Plan;

use App\Models\License;
use App\Models\User;
use App\Models\Workspace;
use App\Service\Billing\PlanOverrideResolver;
use App\Service\License\LicenseService;

class PlanService
{
    public const TIER_FREE = 'free';
    public const TIER_PRO = 'pro';
    public const TIER_BUSINESS = 'business';
    public const TIER_ENTERPRISE = 'enterprise';
    public const TIER_SELF_HOSTED = 'self_hosted';

    /**
     * Tier order for comparison (higher = more features)
     */
    public const TIER_ORDER = [
        self::TIER_FREE => 0,
        self::TIER_PRO => 1,
        self::TIER_BUSINESS => 2,
        self::TIER_ENTERPRISE => 3,
        self::TIER_SELF_HOSTED => 4,
    ];

    /**
     * Cache TTL in seconds (15 minutes, matching existing workspace caching)
     */
    private const CACHE_TTL = 15 * 60;

    /**
     * Get the current plan tier for a user (cached via model).
     */
    public function getUserTier(User $user): string
    {
        if (!pricing_enabled()) {
            return $this->getSelfHostedTier();
        }

        // Use same caching pattern as existing is_subscribed attribute
        return $user->remember('plan_tier', self::CACHE_TTL, function () use ($user): string {
            return $this->computeUserTier($user);
        });
    }

    /**
     * Compute user tier (uncached - internal use).
     * Checks all subscriptions since Cashier's subscription() only returns type='default'.
     */
    public function computeUserTier(User $user): string
    {
        // Check for active license first (AppSumo, special deals)
        if ($license = $user->activeLicense()) {
            return $this->licenseToTier($license);
        }

        // Check all Stripe subscriptions and pick highest tier
        $highestTier = self::TIER_FREE;

        foreach ($user->subscriptions as $subscription) {
            if (!$subscription->valid()) {
                continue;
            }
            $tier = $this->subscriptionToTier($subscription);
            if (self::TIER_ORDER[$tier] > self::TIER_ORDER[$highestTier]) {
                $highestTier = $tier;
            }
        }

        return $highestTier;
    }

    /**
     * Get the effective tier for a workspace (cached via model).
     * Checks workspace overrides first, then highest tier among owners.
     */
    public function getWorkspaceTier(Workspace $workspace): string
    {
        if (!pricing_enabled()) {
            return $this->getSelfHostedTier();
        }

        // Use workspace's caching mechanism (same as existing is_pro)
        return $workspace->remember('plan_tier', self::CACHE_TTL, function () use ($workspace): string {
            return $this->computeWorkspaceTier($workspace);
        });
    }

    /**
     * Compute workspace tier (uncached - internal use).
     */
    public function computeWorkspaceTier(Workspace $workspace): string
    {
        // 1. Check for workspace-level tier override (admin-granted)
        $overrides = $this->getEffectiveOverrides($workspace);
        $overrideTier = $overrides['tier'] ?? null;
        if ($overrideTier !== null && isset(self::TIER_ORDER[$overrideTier])) {
            return $overrideTier;
        }

        // 2. Find highest tier among workspace owners
        $owners = $workspace->relationLoaded('users')
            ? $workspace->users->where('pivot.role', 'admin')
            : $workspace->owners()->get();

        $highestTier = self::TIER_FREE;

        foreach ($owners as $owner) {
            // Don't use cached to avoid nested caching issues
            $ownerTier = $this->computeUserTier($owner);
            if (self::TIER_ORDER[$ownerTier] > self::TIER_ORDER[$highestTier]) {
                $highestTier = $ownerTier;
            }
        }

        return $highestTier;
    }

    /**
     * Check if a tier has access to a specific feature.
     */
    public function tierHasFeature(string $tier, string $feature): bool
    {
        $features = config('plans.features', []);
        $requiredTier = $features[$feature] ?? null;

        // Also check form_features if not found in features
        if ($requiredTier === null) {
            $formFeatures = config('plans.form_features', []);
            $requiredTier = $formFeatures[$feature] ?? null;
        }

        if ($requiredTier === null) {
            return true;
        }

        return $this->tierMeetsRequirement($tier, $requiredTier);
    }

    /**
     * Get a limit value for a specific tier.
     */
    public function getTierLimit(string $tier, string $limitKey): mixed
    {
        $limits = config('plans.limits', []);

        return $limits[$limitKey][$tier] ?? null;
    }

    /**
     * Compare two tiers. Returns true if $tier >= $requiredTier.
     */
    public function tierMeetsRequirement(string $tier, string $requiredTier): bool
    {
        $tierOrder = self::TIER_ORDER[$tier] ?? 0;
        $requiredOrder = self::TIER_ORDER[$requiredTier] ?? 0;

        return $tierOrder >= $requiredOrder;
    }

    /**
     * Get the required tier for a feature (for UI display).
     */
    public function getRequiredTier(string $feature): ?string
    {
        $features = config('plans.features', []);
        $tier = $features[$feature] ?? null;

        if ($tier === null) {
            $formFeatures = config('plans.form_features', []);
            $tier = $formFeatures[$feature] ?? null;
        }

        return $tier;
    }

    /**
     * Get display name for a tier.
     */
    public function getTierDisplayName(string $tier): string
    {
        return config("plans.tiers.{$tier}.name", ucfirst($tier));
    }

    /**
     * Convert subscription to tier based on subscription type (name).
     */
    protected function subscriptionToTier($subscription): string
    {
        // Use subscription type (name) to determine tier
        $tierMapping = config('plans.subscription_tier_mapping', []);

        return $tierMapping[$subscription->type] ?? self::TIER_PRO;
    }

    /**
     * Convert license to tier.
     *
     * IMPORTANT: AppSumo licenses are grandfathered and treated as Pro
     * with their specific limits (file size, domains, users) honored separately.
     */
    protected function licenseToTier(License $license): string
    {
        // AppSumo licenses are always treated as Pro tier for feature access
        // Their specific limits are handled by License model getters
        if ($license->license_provider === 'appsumo') {
            return self::TIER_PRO;
        }

        return self::TIER_PRO;
    }

    /**
     * Check if workspace has access to a specific feature.
     * Considers workspace overrides.
     */
    public function workspaceHasFeature(Workspace $workspace, string $feature): bool
    {
        // 1. Check workspace-level feature override
        $overrideFeatures = $this->getEffectiveOverrides($workspace)['features'] ?? [];
        if (in_array($feature, $overrideFeatures)) {
            return true;
        }

        // 2. Self-hosted: use license-based feature check
        if (!pricing_enabled() && config('app.self_hosted')) {
            return app(LicenseService::class)->hasAppFeature($feature);
        }

        // 3. Check tier-based access
        $tier = $this->getWorkspaceTier($workspace);

        return $this->tierHasFeature($tier, $feature);
    }

    /**
     * Determine tier for self-hosted instances based on license status.
     * With active license → Self-hosted (full features).
     * Without license → Pro (basic self-hosted features).
     */
    private function getSelfHostedTier(): string
    {
        if (!config('app.self_hosted')) {
            return self::TIER_ENTERPRISE;
        }

        $result = app(LicenseService::class)->checkLicense();

        return $result->isActive() ? self::TIER_SELF_HOSTED : self::TIER_PRO;
    }

    /**
     * Get a limit for a workspace, considering overrides and licenses.
     */
    public function getWorkspaceLimit(Workspace $workspace, string $limitKey): mixed
    {
        // 1. Check workspace-level override
        $overrideLimit = $this->getEffectiveOverrides($workspace)['limits'][$limitKey] ?? null;
        if ($overrideLimit !== null) {
            return $overrideLimit;
        }

        // 2. Check for AppSumo/License limits (they have their own limit methods)
        // This is handled at the Workspace model level for max_file_size, etc.

        // 3. Use tier-based limit
        $tier = $this->getWorkspaceTier($workspace);

        return $this->getTierLimit($tier, $limitKey);
    }

    private function getEffectiveOverrides(Workspace $workspace): array
    {
        return app(PlanOverrideResolver::class)->getEffectiveOverrides($workspace);
    }
}