kasy-cli 1.2.1

package/lib/scaffold/features/revenuecat/lib/core/data/models/subscription.dart

@@ -0,0 +1,322 @@
+import 'package:flutter/material.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+import 'package:kasy_kit/features/subscription/api/entities/subscription_entity.dart';
+import 'package:purchases_flutter/purchases_flutter.dart';
+
+part 'subscription.freezed.dart';
+
+abstract class SubscriptionProduct {
+  /// Unique identifier of the product in the store
+  String get skuId;
+
+  /// Unique identifier
+  String get id;
+
+  /// Description of the subscription from your app
+  String get description;
+
+  /// Label of the subscription from the package in revenue cat
+  String get label;
+
+  /// Price of the subscription
+  double get price;
+
+  /// Duration of the subscription
+  Duration get duration;
+
+  /// Promotion of the subscription (configure it in the revenue cat offering json)
+  String? get promotion;
+
+  /// Formatted price with duration from the user locale
+  String formattedPrice(BuildContext context);
+
+  /// Duration type of the subscription (week, month, year, ...)
+  DurationType get durationType;
+
+  /// Title of the offer
+  String? get title;
+
+  /// Trial days of the offer
+  int? get trialDays;
+
+  /// Features textes of the offer
+  List<String>? get features;
+
+  /// Price of the subscription in string
+  String get priceString;
+
+  String get currency;
+
+  /// Shows the price per month (only if the duration is not monthly)
+  String pricePerMonth(BuildContext context);
+
+  /// Shows the price per year (only if the duration is not yearly)
+  String? pricePerYear(BuildContext context);
+}
+
+class RevenueCatProduct implements SubscriptionProduct {
+  final Offering revenueCatOffer;
+  final Package revenueCatPackage;
+
+  RevenueCatProduct({
+    required this.revenueCatOffer,
+    required this.revenueCatPackage,
+  });
+
+  @override
+  String get skuId => revenueCatPackage.identifier;
+
+  @override
+  String get id => revenueCatOffer.identifier;
+
+  @override
+  String get description => revenueCatOffer.serverDescription;
+
+  @override
+  String get label =>
+      revenueCatPackage.presentedOfferingContext.offeringIdentifier;
+
+  @override
+  double get price => revenueCatPackage.storeProduct.price;
+
+  @override
+  String get currency => revenueCatPackage.storeProduct.currencyCode;
+
+  @override
+  int? get trialDays {
+    final introductory = revenueCatPackage.storeProduct.introductoryPrice;
+    if (introductory == null) {
+      return null;
+    }
+    if (introductory.price == 0) {
+      final unit = introductory.periodUnit;
+      switch (unit) {
+        case PeriodUnit.day:
+          return introductory.periodNumberOfUnits;
+        case PeriodUnit.week:
+          return introductory.periodNumberOfUnits * 7;
+        case PeriodUnit.month:
+          return introductory.periodNumberOfUnits * 30;
+        case PeriodUnit.year:
+          return introductory.periodNumberOfUnits * 365;
+        default:
+          return null;
+      }
+    }
+    return null;
+  }
+
+  @override
+  String? get promotion {
+    if (revenueCatOffer.metadata["promotions"] == null) {
+      return null;
+    }
+    final data =
+        revenueCatOffer.metadata["promotions"]! as Map<Object?, Object?>;
+    final locale = LocaleSettings.currentLocale.languageCode;
+    final id = skuId;
+    if (data.containsKey(id)) {
+      final promotion = data[id]! as Map<Object?, Object?>;
+      return promotion[locale]! as String;
+    }
+    return null;
+  }
+
+  @override
+  String? get title {
+    return revenueCatPackage.storeProduct.title;
+  }
+
+  @override
+  List<String>? get features {
+    final locale = LocaleSettings.currentLocale.languageCode;
+    if (revenueCatOffer.metadata[locale] == null) {
+      return null;
+    }
+    final data = revenueCatOffer.metadata[locale]! as Map<Object?, Object?>;
+    final featuerObj = data["features"]! as List<Object?>;
+    return featuerObj.map((e) => e! as String).toList();
+  }
+
+  @override
+  String get priceString {
+    return revenueCatPackage.storeProduct.priceString;
+  }
+
+  @override
+  Duration get duration =>
+      switch (revenueCatPackage.storeProduct.subscriptionPeriod) {
+        'P1W' => const Duration(days: 7),
+        'P1M' => const Duration(days: 30),
+        'P3M' => const Duration(days: 90),
+        'P6M' => const Duration(days: 180),
+        'P1Y' => const Duration(days: 365),
+        _ => Duration.zero,
+      };
+
+  @override
+  DurationType get durationType {
+    final durationCpy = duration;
+    if (durationCpy.inDays == 7) {
+      return DurationType.week;
+    } else if (durationCpy.inDays == 30) {
+      return DurationType.month;
+    } else if (durationCpy.inDays == 90) {
+      return DurationType.threeMonth;
+    } else if (durationCpy.inDays == 180) {
+      return DurationType.sixMonth;
+    } else if (durationCpy.inDays == 365) {
+      return DurationType.year;
+    }
+    return DurationType.lifetime;
+  }
+
+  @override
+  String formattedPrice(BuildContext context) {
+    final translatedDuration = switch (durationType) {
+      DurationType.week => Translations.of(context).premium.duration_weekly,
+      DurationType.year => Translations.of(context).premium.duration_annual,
+      DurationType.month => Translations.of(context).premium.duration_monthly,
+      DurationType.lifetime => Translations.of(
+        context,
+      ).premium.duration_lifetime,
+      _ => "",
+    };
+    return "${revenueCatPackage.storeProduct.priceString} $translatedDuration";
+  }
+
+  @override
+  String pricePerMonth(BuildContext context) {
+    final translatedDuration = Translations.of(
+      context,
+    ).premium.duration_monthly;
+    if (durationType == DurationType.lifetime) {
+      return revenueCatPackage.storeProduct.priceString;
+    }
+    final pricePerMonth = switch (durationType) {
+      DurationType.year => price / 12,
+      DurationType.threeMonth => price / 3,
+      DurationType.sixMonth => price / 6,
+      DurationType.week => (price * 4) / 12,
+      _ => 1,
+    };
+    final pricePerMonthString = pricePerMonth.toStringAsFixed(2);
+    final money = revenueCatPackage.storeProduct.currencyCode;
+    if (money == "USD") {
+      return "\$$pricePerMonthString/$translatedDuration";
+    } else if (money == "EUR") {
+      return "$pricePerMonthString/$translatedDuration";
+    }
+    return "$pricePerMonthString $money/$translatedDuration";
+  }
+
+  @override
+  String? pricePerYear(BuildContext context) {
+    final translatedDuration = Translations.of(context).premium.duration_annual;
+    if (durationType == DurationType.lifetime) {
+      return revenueCatPackage.storeProduct.priceString;
+    }
+    final pricePerMonth = switch (durationType) {
+      DurationType.year => price,
+      DurationType.threeMonth => price * 4,
+      DurationType.sixMonth => price * 2,
+      DurationType.week => (price * 4) * 12,
+      _ => 1,
+    };
+    final pricePerMonthString = pricePerMonth.toStringAsFixed(2);
+    final money = revenueCatPackage.storeProduct.currencyCode;
+    if (money == "USD") {
+      return "\$$pricePerMonthString/$translatedDuration";
+    } else if (money == "EUR") {
+      return "$pricePerMonthString/$translatedDuration";
+    }
+    return "$pricePerMonthString $money/$translatedDuration";
+  }
+}
+
+enum DurationType { week, month, threeMonth, sixMonth, year, lifetime }
+
+@freezed
+sealed class Subscription with _$Subscription {
+  const factory Subscription.active({
+    SubscriptionProduct? activeOffer,
+    List<EntitlementInfo>? entitlements,
+  }) = SubscriptionStateData;
+
+  const factory Subscription.inactive({
+    required int hoursBetweenTwoRequests,
+    DateTime? lastAskingDate,
+  }) = SubscriptionInactiveStateData;
+
+  const factory Subscription.loading() = SubscriptionStateLoading;
+
+  const Subscription._();
+
+  factory Subscription.fromEntity(
+    SubscriptionEntity? entity,
+    DateTime? lastAskingDate, {
+    int hoursBetweenTwoRequests = 24,
+  }) {
+    if (entity == null ||
+        (entity.periodEndDate != null &&
+            entity.periodEndDate!.isBefore(DateTime.now()))) {
+      return Subscription.inactive(
+        hoursBetweenTwoRequests: hoursBetweenTwoRequests,
+        lastAskingDate: lastAskingDate,
+      );
+    }
+    return const Subscription.active();
+  }
+
+  bool get canPurchase => switch (this) {
+    SubscriptionStateData() => false,
+    SubscriptionInactiveStateData() => true,
+    SubscriptionStateLoading() => false,
+  };
+
+  bool get isActive => switch (this) {
+    SubscriptionStateData() => true,
+    SubscriptionInactiveStateData() => false,
+    SubscriptionStateLoading() => false,
+  };
+
+  bool get isInTrial => switch (this) {
+    SubscriptionStateData(:final entitlements) =>
+      entitlements?.firstOrNull?.periodType == PeriodType.trial,
+    SubscriptionInactiveStateData() => false,
+    SubscriptionStateLoading() => false,
+  };
+
+  bool get hasRenewal => switch (this) {
+    SubscriptionStateData(:final entitlements) =>
+      entitlements?.firstOrNull?.willRenew == true,
+    SubscriptionInactiveStateData() => false,
+    SubscriptionStateLoading() => false,
+  };
+
+  bool get isLifetime => switch (this) {
+    SubscriptionStateData(:final activeOffer) =>
+      activeOffer?.durationType == DurationType.lifetime,
+    SubscriptionInactiveStateData() => false,
+    SubscriptionStateLoading() => false,
+  };
+
+  bool get shouldAskForSubscription {
+    final now = DateTime.now();
+    final (lastAskingDate, hoursBetweenTwoRequests) = switch (this) {
+      SubscriptionStateData() => (null, null),
+      SubscriptionInactiveStateData(
+        :final lastAskingDate,
+        :final hoursBetweenTwoRequests,
+      ) =>
+        (lastAskingDate, hoursBetweenTwoRequests),
+      SubscriptionStateLoading() => (null, null),
+    };
+    if (lastAskingDate == null) {
+      return true;
+    }
+    final diff = now.difference(lastAskingDate);
+    return diff.inHours >= hoursBetweenTwoRequests!;
+  }
+}

package/lib/scaffold/features/revenuecat/lib/core/home_widgets/home_widget_background_task.dart

@@ -0,0 +1,41 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+import 'package:kasy_kit/core/home_widgets/home_widget_mywidget_service.dart';
+import 'package:kasy_kit/core/shared_preferences/shared_preferences.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/features/authentication/api/authentication_api.dart';
+import 'package:kasy_kit/features/subscription/repositories/subscription_repository.dart';
+
+/// Generated by Kasy CLI
+/// ----
+/// Background task callback for workmanager
+/// This allows updating home widgets even when the app is in the background
+@pragma('vm:entry-point')
+Future<void> homeWidgetCallbackDispatcher() async {
+  try {
+    Logger().i('🔄 Home Widget background task triggered');
+    final globalContainer = ProviderContainer();
+    final sharedPreferences = globalContainer.read(sharedPreferencesProvider);
+    await sharedPreferences.init();
+    await globalContainer.read(authenticationApiProvider).init();
+    await globalContainer.read(subscriptionRepositoryProvider).init();
+    await globalContainer.read(userStateNotifierProvider.notifier).init();
+
+    /// If you want to restric the background task to only run when the user is subscribed,
+    /// you can use the subscription variable here.
+    // final subscription = globalContainer
+    //     .read(userStateNotifierProvider)
+    //     .subscription;
+
+    final myWidgetWidget = globalContainer.read(
+      myWidgetHomeWidgetProvider.notifier,
+    );
+    await myWidgetWidget.update();
+
+    globalContainer.dispose();
+    return;
+  } catch (e) {
+    Logger().e('Error in background task: $e');
+    return;
+  }
+}

package/lib/scaffold/features/revenuecat/lib/core/states/user_state_notifier.dart

@@ -0,0 +1,305 @@
+import 'package:flutter/foundation.dart';
+import 'package:logger/logger.dart';
+import 'package:kasy_kit/core/config/features.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/data/repositories/user_repository.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/environnements.dart';
+import 'package:kasy_kit/features/authentication/repositories/authentication_repository.dart';
+import 'package:kasy_kit/features/notifications/providers/models/device.dart';
+import 'package:kasy_kit/features/notifications/repositories/device_repository.dart';
+import 'package:purchases_flutter/models/entitlement_info_wrapper.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'user_state_notifier.g.dart';
+
+/// Use this provider to access the user state (legacy name)
+final userStateNotifierProvider = userStateProvider;
+
+/// This enum is used to parameter the list of the authentication mode
+///
+/// Most of apps try to not force user to create an account to access the app
+/// But you may want to force the user to be authenticated to access the app
+enum AuthenticationMode {
+  /// By default the user will be authenticated anonymously
+  /// This means that the user can access your app without login
+  /// He will be able to link his account later to an email or social login
+  anonymous,
+
+  /// The user requires to be authenticated to access the app
+  /// By default the user won't have any identity
+  authRequired,
+}
+
+/// This class is responsible for managing the state of the user over the app.
+/// It will be used to know if the user is connected or not and to get the user
+@Riverpod(keepAlive: true)
+class UserStateNotifier extends _$UserStateNotifier implements OnStartService {
+  Logger get _logger => Logger();
+
+  AuthenticationRepository get _authenticationRepository =>
+      ref.read(authRepositoryProvider);
+
+  DeviceRepository get _deviceRepository => ref.read(deviceRepositoryProvider);
+
+  UserRepository get _userRepository => ref.read(userRepositoryProvider);
+
+  /// The authentication mode of the app.
+  /// On web (when withWeb is true), always require explicit auth —
+  /// anonymous accounts are not used on web.
+  /// see [AuthenticationMode]
+  AuthenticationMode get mode {
+    if (kIsWeb && withWeb) return AuthenticationMode.authRequired;
+    return ref.read(environmentProvider).authenticationMode;
+  }
+
+  @override
+  UserState build() {
+    return const UserState(user: User.loading());
+  }
+
+  @override
+  Future<void> init() async {
+    try {
+      await _loadState();
+    } catch (e, stacktrace) {
+      _logger.e(e, stackTrace: stacktrace);
+      if(kDebugMode) {
+        // we automatically logout the user if an error occurs in debug mode
+        // customize this behavior to fit your needs
+        _authenticationRepository.logout();
+      }
+      rethrow;
+    }
+    assert(state.user is! LoadingUserData, 'UserStateNotifier is not ready');
+    await _initDeviceRegistration();
+    _deviceRepository.onTokenUpdate(_onUpdateToken);
+  }
+
+  /// This function is called when the user click on the signin button
+  /// It will load the user state and register the device to the notification service
+  /// It will also load the subscription state
+  Future<void> onSignin() async {
+    state = const UserState(
+      user: User.loading(),
+    );
+    await _loadState();
+    await _initDeviceRegistration();
+  }
+
+  /// Set the user as onboarded in the database
+  /// This function is called when the user has completed the onboarding
+  Future<void> onOnboarded() async {
+    if (state.user.idOrNull == null) {
+      // Guest with no account: persist onboarding in local state only.
+      // No Firestore document exists yet — no write needed.
+      state = state.copyWith(user: const User.anonymous(onboarded: true));
+      return;
+    }
+    final newUser = await _userRepository.setOnboarded(state.user);
+    state = state.copyWith(user: newUser);
+  }
+
+  /// This function is called when the user click on the logout button
+  /// It will unregister the device from the notification service
+  /// and logout the user
+  Future<void> onLogout() async {
+    final userId = state.user.idOrThrow;
+    _deviceRepository.removeTokenUpdateListener();
+    await _deviceRepository.unregister(userId);
+    await _authenticationRepository.logout();
+    state = const UserState(
+      user: User.anonymous(),
+    );
+    if (mode == AuthenticationMode.anonymous) {
+      await _loadAnonymousState();
+    }
+  }
+
+  /// Refresh the user
+  Future<void> onUpdateAvatar() async {
+    await refresh();
+  }
+
+  /// Refresh the user
+  Future<void> refresh() async {
+    final id = state.user.idOrNull;
+    if (id == null) return; // Guest: no Firestore document, nothing to refresh
+    final user = await _userRepository.get(id);
+    state = state.copyWith(user: user ?? const User.anonymous());
+  }
+
+  /// This function is called after a user successfuly purchased a subscription
+  /// It will refresh the subscription state without waiting for the webhook
+  /// (which can take some time and could show a wrong state to the user)
+  /// On next app start, the subscription will be refreshed from the webhook result
+  Future<void> refreshSubscription({
+    SubscriptionProduct? product,
+    List<EntitlementInfo>? entitlements,
+  }) async {
+    if (product != null) {
+      final newUser = switch (state.user) {
+        final AuthenticatedUserData user => user.copyWith(
+          subscription: Subscription.active(
+            activeOffer: product,
+            entitlements: entitlements,
+          ),
+        ),
+        final AnonymousUserData user => user.copyWith(
+          subscription: Subscription.active(
+            activeOffer: product,
+            entitlements: entitlements,
+          ),
+        ),
+        final LoadingUserData _ => throw 'User is not connected',
+      };
+      state = state.copyWith(user: newUser);
+      return;
+    }
+    await Future.delayed(const Duration(seconds: 2));
+    await _loadState();
+  }
+
+  /// Apple store and Google play stores requires you to be able to delete a user account on demand
+  /// Here is the function to do it.
+  /// It will delete the user account and logout the user
+  Future<void> deleteAccount() async {
+    try {
+      final userId = state.user.idOrThrow;
+      _deviceRepository.removeTokenUpdateListener();
+      await _deviceRepository.unregister(userId);
+      await _userRepository.delete();
+      await _authenticationRepository.logout();
+    } catch (e) {
+      _logger.e(e);
+    }
+    state = const UserState(
+      user: User.anonymous(),
+    );
+
+    if (mode == AuthenticationMode.anonymous) {
+      await _loadAnonymousState();
+    }
+  }
+
+  // -------------------------------
+  // PRIVATES
+  // -------------------------------
+
+  /// load anonymous state for the user
+  Future<void> _loadAnonymousState() async {
+    await _authenticationRepository.signupAnonymously();
+    await Future.delayed(const Duration(seconds: 1));
+    final credentials = await _authenticationRepository.get();
+    var user = await _userRepository.get(credentials!.id);
+    // We retry to get the user 3 times (sometimes the user creation trigger is not fast enough)
+    var retry = 0;
+    while (user == null && retry < 3) {
+      await Future.delayed(const Duration(seconds: 1));
+      user = await _userRepository.get(credentials.id);
+      retry++;
+    }
+    if (user == null) {
+      // Backend not deployed yet: the Cloud Function onUserRegistration has not
+      // created the Firestore document. Log the issue for the developer and fall
+      // back to a local anonymous state so the app still opens.
+      _logger.e(
+        '⚠️  User profile not found in database.\n'
+        '    The backend may not be deployed yet.\n'
+        '    Run: kasy deploy\n'
+        '    Then restart the app.',
+      );
+      state = state.copyWith(user: User.anonymous(id: credentials.id));
+      return;
+    }
+    state = state.copyWith(user: user);
+  }
+
+  /// Load the state of the user
+  Future<void> _loadState() async {
+    final credentials = await _authenticationRepository.get();
+
+    if (credentials == null && mode == AuthenticationMode.anonymous) {
+      _logger.i('Anonymous user mode activated, signup anonymously');
+      await _loadAnonymousState();
+    } else if (credentials == null && mode == AuthenticationMode.authRequired) {
+      _logger.i('Authentification required, user is not connected');
+      state = state.copyWith(user: const User.anonymous());
+    } else if (credentials != null) {
+      _logger.i('User is connected with id ${credentials.id}');
+      var user = await _userRepository.get(credentials.id);
+      // Retry a few times: the Cloud Function onUserRegistration may not have
+      // finished creating the Firestore document yet (race condition on first login).
+      var retry = 0;
+      while (user == null && retry < 3) {
+        await Future.delayed(const Duration(seconds: 1));
+        user = await _userRepository.get(credentials.id);
+        retry++;
+      }
+      if (user == null) {
+        // User document not found after login. Possible causes:
+        // - Firebase: onUserRegistration Cloud Function not deployed or failed
+        // - Supabase: handle_new_user trigger not run yet (race) or failed
+        // - User was deleted but session was still cached
+        // Logout to clear invalid session, then create new anonymous user if applicable.
+        _logger.e(
+          '⚠️  User profile not found in database after sign-in.\n'
+          '    Logging out and creating new anonymous user.',
+        );
+        await _authenticationRepository.logout();
+        state = state.copyWith(user: const User.anonymous());
+        if (mode == AuthenticationMode.anonymous) {
+          await _loadAnonymousState();
+        }
+        return;
+      }
+      // If the Firestore document is anonymous (no email) but Firebase Auth
+      // already has an email (happens after linkWithProvider — Google, email, etc.),
+      // sync the email and name so the user is properly recognised as authenticated.
+      if (user is AnonymousUserData) {
+        final authEmail = await _authenticationRepository.getCurrentUserEmail();
+        if (authEmail != null && authEmail.isNotEmpty) {
+          final authName = await _authenticationRepository.getCurrentUserDisplayName();
+          await _userRepository.updateEmailAndName(
+            userId: credentials.id,
+            email: authEmail,
+            name: authName,
+          );
+          final syncedUser = await _userRepository.get(credentials.id);
+          state = state.copyWith(user: syncedUser ?? user);
+          return;
+        }
+      }
+      state = state.copyWith(user: user);
+    }
+  }
+
+  /// If user has an ID we will register his device to send notifications from
+  /// the server to the device (only if user has accepted them)
+  /// Maybe save your device in UserState if you need it in your app
+  Future<void> _initDeviceRegistration() async {
+    if (kIsWeb) return;
+    final userId = state.user.idOrNull;
+    if (userId == null) {
+      return;
+    }
+    try {
+      final _ = await _deviceRepository.register(userId);
+    } catch (err, stacktrace) {
+      _logger.e(err, stackTrace: stacktrace);
+      _logger.e('''
+          ❌ Your device seems not to be registered.
+          Check that you correctly setup a device registration API
+          see: `lib/features/notifications/api/device_api.dart`
+        ''');
+    }
+  }
+
+  /// This function is called when the device token is updated
+  /// It will update the token in the database
+  Future<void> _onUpdateToken(Device device) async {
+    await _deviceRepository.updateToken(device.token);
+  }
+}