Beautiful Open-Source Form Builder
<?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);
}
}