kasy-cli 1.2.1

package/templates/firebase/lib/features/subscription/providers/premium_page_provider.dart

@@ -0,0 +1,259 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart' show PlatformException;
+import 'package:kasy_kit/core/data/api/analytics_api.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/core/states/translations.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/core/toast/toast_service.dart';
+import 'package:kasy_kit/features/feedbacks/repositories/feature_request_repository.dart';
+import 'package:kasy_kit/features/subscription/api/inapp_subscription_api.dart'
+    show UserCancelledPurchaseException;
+import 'package:kasy_kit/features/subscription/providers/models/premium_state.dart';
+import 'package:kasy_kit/features/subscription/repositories/subscription_repository.dart';
+import 'package:kasy_kit/router.dart';
+import 'package:logger/logger.dart';
+import 'package:purchases_flutter/purchases_flutter.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:sentry_flutter/sentry_flutter.dart';
+
+part 'premium_page_provider.g.dart';
+
+@Riverpod()
+class PremiumStateNotifier extends _$PremiumStateNotifier {
+  final Logger _logger = Logger();
+
+  UserState get _userState => ref.read(userStateNotifierProvider);
+
+  SubscriptionRepository get _subscriptionRepository =>
+      ref.read(subscriptionRepositoryProvider);
+
+  AnalyticsApi? get _analyticsApi => ref.read(analyticsApiProvider);
+
+  @override
+  Future<PremiumState> build() async {
+    try {
+      // If you have installed the remote config brick
+      // you can use it like this
+      // RemoteConfig is amazing to manage and test different settings for paywalls
+      // ex: you can test different title and texts
+      // final remoteConfigApi = ref.watch(remoteConfigApiProvider);
+      // print(remoteConfigApi.subscription.title.value);
+      final offers = await _subscriptionRepository.getOffers();
+      if (offers.isEmpty) {
+        _logger.w(
+          'RevenueCat returned no subscription offers. The paywall will show '
+          'an empty-products state instead of a blank screen.',
+        );
+        return const PremiumState(offers: []);
+      }
+
+      return switch (_userState.subscription) {
+        SubscriptionStateData(:final activeOffer) => PremiumState.active(
+          activeOffer: offers.firstWhere(
+            (element) => element.skuId == activeOffer?.skuId,
+            orElse: () => offers.first,
+          ),
+        ),
+        SubscriptionInactiveStateData() => PremiumState(
+          offers: offers,
+          selectedOffer: offers.first,
+        ),
+        _ => PremiumState(offers: offers, selectedOffer: offers.first),
+      };
+    } catch (err, stack) {
+      // RevenueCat CONFIGURATION_ERROR (code 23) means the products exist in the
+      // dashboard but aren't live on the store yet (e.g. "Ready to Submit").
+      // This is expected before the first app submission — skip Sentry noise.
+      final isConfigError = err is PlatformException &&
+          (err.details as Map?)?['readableErrorCode'] == 'CONFIGURATION_ERROR';
+      if (isConfigError) {
+        _logger.w(
+          'RevenueCat CONFIGURATION_ERROR: products not yet live on App Store. '
+          'Showing empty paywall state.',
+        );
+      } else {
+        await Sentry.captureException(err, stackTrace: stack);
+        _logger.e(
+          '...PremiumStateNotifier: init failed, '
+          '👉 Make sure you have properly setup subscription '
+          'following our guide (https://kasy.dev/docs/monetize/subscription-template/) '
+          '$err --> $stack',
+          stackTrace: stack,
+        );
+      }
+      return const PremiumStateData(offers: []);
+    }
+  }
+
+  Future<void> startCoupon() async {
+    if (TargetPlatform.iOS != defaultTargetPlatform) {
+      return;
+    }
+    await Purchases.presentCodeRedemptionSheet();
+  }
+
+  void selectOffer(SubscriptionProduct offer) {
+    if (state.value == null) {
+      throw "cannot select offer";
+    }
+    final newState = switch (state.value!) {
+      final PremiumStateData el => el.copyWith(selectedOffer: offer),
+      final PremiumStateActive el => el.copyWith(activeOffer: offer),
+      _ => null,
+    };
+    if (newState == null) {
+      throw "cannot select offer";
+    }
+    state = AsyncValue.data(newState);
+  }
+
+  Future<void> purchase({String? paywall, String? redirectRoute}) async {
+    if (state.value is! PremiumStateData) {
+      throw "cannot purchase without offers";
+    }
+    final offer = state.value?.selectedOffer;
+    if (offer == null) {
+      throw "cannot purchase without selected offer";
+    }
+    await purchaseOffer(offer, paywall: paywall, redirectRoute: redirectRoute);
+  }
+
+  Future<void> purchaseOffer(
+    SubscriptionProduct offer, {
+    String? paywall,
+    String? redirectRoute,
+  }) async {
+    state = switch (state.value) {
+      PremiumStateData(:final offers) => AsyncData(
+        PremiumState.sending(
+          isPremium: false,
+          offers: offers,
+          selectedOffer: offer,
+        ),
+      ),
+      _ => throw "cannot purchase while active",
+    };
+    try {
+      final entitlements = await _subscriptionRepository.purchase(offer);
+      state = AsyncData(PremiumState.active(activeOffer: offer));
+      await _analyticsApi?.logEvent("purchase", {
+        "skuId": offer.skuId,
+        "price": offer.price,
+        // "promotion": offer.promotion,
+        "duration": offer.duration,
+        "paywall": paywall,
+      });
+      // let's refresh the user state
+      await ref
+          .read(userStateNotifierProvider.notifier)
+          .refreshSubscription(product: offer, entitlements: entitlements);
+      final t = ref.read(translationsProvider);
+      ref
+          .read(toastProvider)
+          .success(
+            title: t.premium.purchase_success_title,
+            text: t.premium.purchase_success_text,
+          );
+      await Future.delayed(const Duration(seconds: 2));
+      if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+    } catch (err, stackTrace) {
+      state = switch (state.value) {
+        PremiumStateData(:final offers) => AsyncData(
+          PremiumState(offers: offers, selectedOffer: offer),
+        ),
+        PremiumStateSending(:final offers) => AsyncData(
+          PremiumState(offers: offers, selectedOffer: offer),
+        ),
+        PremiumStateActive() => state,
+        _ => throw "cannot purchase while active",
+      };
+      if (err is UserCancelledPurchaseException) return;
+      await Sentry.captureException(err, stackTrace: stackTrace);
+      _logger.e("...PremiumStateNotifier: purchase failed $err : $stackTrace");
+      final t = ref.read(translationsProvider);
+      ref
+          .read(toastProvider)
+          .error(
+            title: t.premium.error_title,
+            text: t.premium.error_text,
+            reason: "We were unable to process your subscription",
+          );
+    }
+  }
+
+  Future<void> unsubscribe() async {
+    // _analytics.logPageOpened("launch_unsubscribe_page");
+    await _subscriptionRepository.unsubscribe();
+  }
+
+  Future<void> saveUnsubscribeReason(String reason) async {
+    try {
+      final userId = _userState.user.idOrNull;
+      if (userId == null) return;
+      await ref
+          .read(featureRequestRepositoryProvider)
+          .createNewFeatureSuggestion(
+            userId: userId,
+            title: "unsubscribed",
+            description: reason,
+          );
+      _logger.i('👉 Unsubscribe reason saved successfully');
+    } catch (err, stackTrace) {
+      _logger.e('👉 Error saving unsubscribe reason: $err : $stackTrace');
+      await Sentry.captureException(err, stackTrace: stackTrace);
+      // Don't rethrow as we don't want to block the unsubscribe process
+    }
+  }
+
+  Future<void> restore({String? redirectRoute}) async {
+    if (state.value is! PremiumStateData) {
+      throw "cannot restore while active";
+    }
+    final data = state.value! as PremiumStateData;
+
+    // Only enter loading state when there are offers to display; with an empty
+    // offer list the paywall already shows the empty-state UI.
+    if (data.offers.isNotEmpty) {
+      state = AsyncData(
+        PremiumState.sending(
+          isPremium: false,
+          offers: data.offers,
+          selectedOffer: data.selectedOffer,
+        ),
+      );
+    }
+
+    try {
+      await _subscriptionRepository.restorePurchase();
+      final t = ref.read(translationsProvider);
+      ref
+          .read(toastProvider)
+          .success(
+            title: t.premium.restore_success_title,
+            text: t.premium.restore_success_text,
+          );
+      await Future.delayed(const Duration(seconds: 2));
+      if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+    } catch (err, trace) {
+      _logger.e("Error while restoring purchase: $err : $trace");
+      state = AsyncData(
+        PremiumStateData(offers: data.offers, selectedOffer: data.selectedOffer),
+      );
+      final t = ref.read(translationsProvider);
+      ref
+          .read(toastProvider)
+          .error(
+            title: t.premium.error_title,
+            text: t.premium.error_text,
+            reason: "We were unable to restore your subscription",
+          );
+    }
+  }
+}
+
+class SubscriptionException implements Exception {
+  final String message;
+
+  SubscriptionException(this.message);
+}

package/templates/firebase/lib/features/subscription/repositories/subscription_repository.dart

@@ -0,0 +1,177 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:kasy_kit/core/shared_preferences/shared_preferences.dart';
+import 'package:kasy_kit/features/subscription/api/inapp_subscription_api.dart';
+import 'package:kasy_kit/features/subscription/api/subscription_api.dart';
+import 'package:logger/logger.dart';
+import 'package:purchases_flutter/errors.dart';
+import 'package:purchases_flutter/models/entitlement_info_wrapper.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+final subscriptionRepositoryProvider = Provider(
+  (ref) => SubscriptionRepository(
+    subscriptionApi: ref.watch(subscriptionApiProvider),
+    inAppSubscriptionApi: ref.watch(inAppSubscriptionApiProvider),
+    prefs: ref.watch(sharedPreferencesProvider).prefs,
+    // remoteConfig: ref.watch(remoteConfigApiProvider),
+  ),
+);
+
+const _lastAskKey = 'subscription_last_asking_date';
+
+/// This class is responsible for managing the subscription of the user
+/// It will be used to know if the user is subscribed or not and to get the subscription
+/// A fake implementation of the revenue cat is used for units test see: [InAppSubscriptionApiFake]
+class SubscriptionRepository implements OnStartService {
+  final SubscriptionApi _subscriptionApi;
+
+  final RevenueCatPaymentApi _inAppSubscriptionApi;
+
+  final SharedPreferences? _prefs;
+
+  final Logger _logger;
+
+  /// You can use the remote config to configure the subscription module
+  /// For example, you can set the number of hours between two requests to the API
+  // final RemoteConfigApi? _remoteConfig;
+
+  SubscriptionRepository({
+    required SubscriptionApi subscriptionApi,
+    required RevenueCatPaymentApi inAppSubscriptionApi,
+    required SharedPreferences? prefs,
+    // RemoteConfigApi? remoteConfig,
+    Logger? logger,
+  })  : _subscriptionApi = subscriptionApi,
+        _logger = logger ?? Logger(),
+        _prefs = prefs,
+        // _remoteConfig = remoteConfig,
+        _inAppSubscriptionApi = inAppSubscriptionApi;
+
+  @override
+  Future<void> init() async {
+    try {
+      // We must init the subscription API
+      await _inAppSubscriptionApi.init();
+    } catch (e) {
+      _logger.w('''
+        Revenuecat seems not to be initialized. 
+        👉 Please check that you have setup your account on https://revenuecat.com
+        And that you have added your token in the environment file or variable (see lib/environnements.dart)
+        or
+        👉 Remove completely the subscription module if you don't need it
+      ''');
+    }
+  }
+
+  // We use a custom subscriber id to be able to identify the user
+  Future<void> initUser(String userId) async {
+    await _inAppSubscriptionApi.initUser(userId);
+    
+  }
+
+  /// We get the subscription of the user
+  /// We fetch the subscription from our own API and not directly from RevenueCat
+  /// So we can grant some free subscription to users easily
+  /// Either you can uncomment the code to directly check from RevenueCat
+  Future<Subscription> get(String userId) async {
+    final entity = await _subscriptionApi.get(userId);
+    final subscription = Subscription.fromEntity(
+      entity,
+      lastAskingDate,
+    );
+    if (subscription.isActive) {
+      final entitlements = await _inAppSubscriptionApi.getEntitlements();
+      final product = await _inAppSubscriptionApi.getFromProductId(
+        entity!.skuId,
+      );
+      
+      return switch(subscription) {
+        final SubscriptionStateData active => active.copyWith(
+          activeOffer: product,
+          entitlements: entitlements,
+        ),
+        _ => subscription,
+      };
+    }
+    // RC fallback: backend has no active record (webhook may not have arrived yet).
+    // RevenueCat is the source of truth for purchases — consult it before
+    // marking the user as inactive.
+    final rcEntitlements = await _inAppSubscriptionApi.getEntitlements();
+    if (rcEntitlements != null && rcEntitlements.isNotEmpty) {
+      _logger.i(
+        'No active backend subscription — RevenueCat reports active entitlements. '
+        'Treating as active (webhook likely delayed).',
+      );
+      return Subscription.active(entitlements: rcEntitlements);
+    }
+    return subscription;
+  }
+
+  // We can have multiple offers (BASIC MONTH, BASIC YEAR, GOLD MONTH, GOLD YEAR, ...)
+  Future<List<SubscriptionProduct>> getOffers({String? offerId}) {
+    return _inAppSubscriptionApi.getOffers(offerId);
+  }
+
+  // We check if the user has a permission
+  // This allows us to add multiple permissions within subscription
+  // If you want only have a single premium subscription, you can create a single permission 'premium'
+  Future<bool> checkPermission(String permissionToCheck) async {
+    final permissions = await _inAppSubscriptionApi.getPermissions();
+    final hasPermission = permissions.any(
+      (e) => e.identifier == permissionToCheck && e.isActive,
+    );
+    if (!hasPermission) throw Exception("Permission denied: $permissionToCheck");
+    return true;
+  }
+
+  /// The purchase method is used to buy a subscription or a product
+  Future<List<EntitlementInfo>?> purchase(SubscriptionProduct product) async {
+    if (product is RevenueCatProduct) {
+      try {
+        await _inAppSubscriptionApi.purchasePackage(product.revenueCatPackage);
+        return _inAppSubscriptionApi.getEntitlements();
+      } on PlatformException catch (e) {
+        final error = PurchasesErrorHelper.getErrorCode(e);
+        if (error == PurchasesErrorCode.purchaseCancelledError) {
+          _logger.i('User has cancelled the purchase');
+          throw UserCancelledPurchaseException();
+        }
+        _logger.e('Error while purchasing the product: $e');
+        rethrow;
+      }
+    }
+    throw Exception('Invalid product');
+  }
+
+  /// Unsubscribe the user
+  /// This will route the user to the subscription management page
+  /// This is handled by the Play Store or the App Store
+  Future<void> unsubscribe() async {
+    await _inAppSubscriptionApi.unsubscribe();
+  }
+
+  /// Restore a previous purchase
+  /// For ex if the user has changed his phone
+  /// he can restore his previous purchase
+  Future<void> restorePurchase() async {
+    await _inAppSubscriptionApi.restorePurchase();
+  }
+
+  /// Save the last time we showed the subscription paywall
+  Future<void> saveLastAskingDate() async {
+    if (_prefs == null) return;
+    final now = DateTime.now();
+    await _prefs.setInt(_lastAskKey, now.millisecondsSinceEpoch);
+  }
+
+  /// Get the last time we showed the subscription paywall
+  DateTime? get lastAskingDate {
+    final lastAsk = _prefs?.getInt(_lastAskKey);
+    if (lastAsk == null) {
+      return null;
+    }
+    return DateTime.fromMillisecondsSinceEpoch(lastAsk);
+  }
+}

package/templates/firebase/lib/features/subscription/shared/maybeshow_premium.dart

@@ -0,0 +1,85 @@
+// ignore_for_file: use_build_context_synchronously
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/config/features.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/shared_preferences/shared_preferences.dart';
+import 'package:kasy_kit/core/states/components/maybeshow_component.dart';
+import 'package:kasy_kit/core/states/models/event_model.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/router.dart';
+
+const _lastAskKey = 'subscription_last_asking_date';
+
+const _kDaysToAsk = 2;
+
+class MaybeShowPremiumPage implements MaybeShowWithRef {
+  @override
+  Future<bool> handle(WidgetRef ref, AppEvent event) async {
+    if (event is! OnAppStartEvent) {
+      return false;
+    }
+    if (kIsWeb && !revenuecatWeb) return false;
+    debugPrint("🧐 MaybeShowPremiumPage");
+    final userState = ref.watch(userStateNotifierProvider);
+    if (userState.subscription?.isActive == true) {
+      return false;
+    }
+    final userCreationDate = switch(userState.user) {
+      AuthenticatedUserData(:final creationDate) => creationDate,
+      AnonymousUserData(:final creationDate) => creationDate,
+      _ => null,
+    };
+
+    if (userCreationDate == null) {
+      return false;
+    }
+    
+    final now = DateTime.now();
+    final prefs = ref.watch(sharedPreferencesProvider).prefs;
+    
+    // await prefs.remove(_lastAskKey);
+    // await prefs.remove(_lastShowPromoKey);
+
+    final lastAskingDate = prefs.getInt(_lastAskKey);
+
+
+    /// 🧐 🧐 🧐 if we have a promo - we only show the promo once or customize it
+    /// ----
+    // final lastShowPromoInMS = prefs.getInt(_lastShowPromoKey);
+    // final lastShowPromoDate = lastShowPromoInMS == null ? null : DateTime.fromMillisecondsSinceEpoch(lastShowPromoInMS);
+    // if (now.isAfter(userCreationDate.add(const Duration(days: 3))) && lastShowPromoDate == null && ref.context.mounted) {
+    //   await prefs.setInt(_lastShowPromoKey, now.millisecondsSinceEpoch);
+    //   await prefs.setInt(_lastAskKey, DateTime.now().millisecondsSinceEpoch);
+    //   PromoBottomSheet.show(ref.context);
+    //   return true;
+    // }
+
+    if (now.isBefore(userCreationDate.add(const Duration(days: 1)))) {
+      return false;
+    }
+    
+    if (lastAskingDate == null) {
+      await prefs.setInt(_lastAskKey, DateTime.now().millisecondsSinceEpoch);
+      showPremiumPage(ref);
+      return true;
+    }
+
+    final lastDate = DateTime.fromMillisecondsSinceEpoch(lastAskingDate);
+    
+    final difference = now.difference(lastDate);
+
+    if (difference.inDays >= _kDaysToAsk) {
+      await prefs.setInt(_lastAskKey, now.millisecondsSinceEpoch);
+      showPremiumPage(ref);
+      return true;
+    }
+    
+    return false;
+  }
+
+  void showPremiumPage(WidgetRef ref) {
+    ref.read(goRouterProvider).push("/premium");
+  }
+}

package/templates/firebase/lib/features/subscription/ui/component/active_premium_content.dart

@@ -0,0 +1,171 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:kasy_kit/components/components.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/core/theme/theme.dart';
+import 'package:kasy_kit/features/subscription/ui/widgets/premium_background.dart';
+import 'package:kasy_kit/features/subscription/ui/widgets/premium_card.dart';
+import 'package:kasy_kit/features/subscription/ui/widgets/unsubscribe_feedback_popup.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+
+typedef OnTapUnSubscribe = void Function(String reason);
+typedef OnExit = void Function();
+
+class ActivePremiumContent extends ConsumerStatefulWidget {
+  final OnTapUnSubscribe? onTap;
+  final OnExit? onExit;
+
+  const ActivePremiumContent({super.key, this.onExit, required this.onTap});
+
+  @override
+  ConsumerState<ActivePremiumContent> createState() =>
+      _ActivePremiumContentState();
+}
+
+class _ActivePremiumContentState extends ConsumerState<ActivePremiumContent> {
+  bool _isPopupShowing = false;
+
+  Future<void> _showUnsubscribePopup(BuildContext context) async {
+    if (_isPopupShowing) return;
+    setState(() => _isPopupShowing = true);
+    try {
+      await UnsubscribeFeedbackPopup.show(
+        context: context,
+        onConfirm: (String reason) {
+          Navigator.of(context).pop();
+          widget.onTap?.call(reason);
+        },
+        onCancel: () {},
+      );
+    } finally {
+      if (mounted) setState(() => _isPopupShowing = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final userState = ref.watch(userStateNotifierProvider);
+
+    return PremiumBackground(
+      bgImagePath: "assets/images/premium-bg.jpg",
+      child: Scaffold(
+        backgroundColor: Colors.transparent,
+        appBar: AppBar(
+          backgroundColor: Colors.transparent,
+          elevation: 0,
+          foregroundColor: context.colors.onPrimary,
+          leading: widget.onExit != null
+              ? KasyButton.iconOnly(
+                  icon: KasyIcons.close,
+                  variant: KasyButtonVariant.ghost,
+                  foregroundColor: context.colors.onPrimary,
+                  onPressed: widget.onExit,
+                  semanticLabel:
+                      MaterialLocalizations.of(context).closeButtonTooltip,
+                )
+              : null,
+          automaticallyImplyLeading: widget.onExit == null,
+        ),
+        body: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Padding(
+              padding: const EdgeInsets.symmetric(horizontal: KasySpacing.pageHorizontalGutter),
+              child: PremiumCard(
+                bgColor: context.colors.onBackground.withValues(alpha: .54),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Padding(
+                      padding: const EdgeInsets.only(bottom: KasySpacing.sm),
+                      child: Chip(
+                        backgroundColor: context.colors.primary,
+                        label: Text(
+                          "ACTIVE",
+                          style: GoogleFonts.albertSans(
+                            fontSize: 12,
+                            fontWeight: FontWeight.w700,
+                            color: context.colors.onPrimary,
+                          ),
+                        ),
+                      ),
+                    ),
+                    Text(
+                      "Premium",
+                      textAlign: TextAlign.center,
+                      style: GoogleFonts.albertSans(
+                        fontSize: 32,
+                        fontWeight: FontWeight.w700,
+                        color: context.colors.onPrimary,
+                      ),
+                    ),
+                    const SizedBox(height: KasySpacing.smd),
+                    // for (var i = 0; i < features.length; i++)
+                    //   Padding(
+                    //     padding: const EdgeInsets.symmetric(horizontal: 8.0),
+                    //     child: FeatureLine(
+                    //       title: translations.features[i],
+                    //       topPadding: i > 0 ? 4 : 0,
+                    //       icon: switch (i) {
+                    //         0 => HugeIcons.strokeRoundedTaskDone02,
+                    //         1 => HugeIcons.strokeRoundedCheckmarkSquare01,
+                    //         2 => HugeIcons.strokeRoundedGame,
+                    //         _ => Icons.check,
+                    //       },
+                    //     ),
+                    //   ),
+                    const SizedBox(height: KasySpacing.xl),
+                    if (userState.subscription?.isLifetime == true)
+                      Padding(
+                        padding: const EdgeInsets.all(KasySpacing.lg),
+                        child: Text(
+                          Translations.of(
+                            context,
+                          ).activePremium.lifetime_user_description,
+                          style: context.textTheme.bodyMedium?.copyWith(
+                            fontWeight: FontWeight.w700,
+                          ),
+                          textAlign: TextAlign.center,
+                        ),
+                      ),
+                    // SliverToBoxAdapter(
+                    //   child: Padding(
+                    //     padding: hPadding,
+                    //     child: ComparisonTable(
+                    //       rows: ComparisonTableRow.getComparisonRows(
+                    //         context,
+                    //         ref.read(environmentProvider),
+                    //       ),
+                    //       freeColumnTitle:
+                    //           ComparisonTableRow.getFreeColumnTitle(context),
+                    //       premiumColumnTitle:
+                    //           ComparisonTableRow.getPremiumColumnTitle(context),
+                    //     ),
+                    //   ),
+                    // ),
+                    if (userState.subscription?.isLifetime == false)
+                      Padding(
+                        padding: const EdgeInsets.fromLTRB(
+                          KasySpacing.pageHorizontalGutter,
+                          72,
+                          KasySpacing.pageHorizontalGutter,
+                          KasySpacing.lg,
+                        ),
+                        child: KasyButton(
+                          label: Translations.of(context).activePremium.unsubscribe_button,
+                          variant: KasyButtonVariant.soft,
+                          expand: true,
+                          onPressed: () => _showUnsubscribePopup(context),
+                        ),
+                      ),
+                  ],
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}