kasy-cli 1.2.1

package/templates/firebase/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/features/subscription/api/entities/subscription_entity.dart';
+import 'package:kasy_kit/i18n/translations.g.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/templates/firebase/lib/core/data/models/user.dart

@@ -0,0 +1,107 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:logger/logger.dart';
+
+part 'user.freezed.dart';
+
+@freezed
+sealed class User with _$User {
+  const factory User.authenticated({
+    required String email,
+    String? name,
+    String? id,
+    DateTime? creationDate,
+    DateTime? lastUpdateDate,
+    String? avatarPath,
+    required bool onboarded,
+    // this will be empty only if you don't use the Subscription module
+    Subscription? subscription,
+  }) = AuthenticatedUserData;
+
+  const factory User.anonymous({
+    String? id,
+    bool? onboarded,
+    Subscription? subscription,
+    DateTime? creationDate,
+    DateTime? lastUpdateDate,
+  }) = AnonymousUserData;
+
+  const factory User.loading() = LoadingUserData;
+
+  const User._();
+
+  factory User.fromEntity(UserEntity? entity) {
+    try {
+      if (entity == null) {
+        return const User.anonymous();
+      }
+      if (entity.email == null) {
+        return User.anonymous(
+          id: entity.id,
+          onboarded: entity.onboarded ?? false,
+          creationDate: entity.creationDate,
+          lastUpdateDate: entity.lastUpdateDate,
+        );
+      }
+      return User.authenticated(
+        id: entity.id,
+        email: entity.email!,
+        name: entity.name,
+        onboarded: entity.onboarded ?? false,
+        avatarPath: entity.avatarPath,
+        creationDate: entity.creationDate,
+        lastUpdateDate: entity.lastUpdateDate,
+      );
+    } catch (e, trace) {
+      Logger().e(e, stackTrace: trace);
+      rethrow;
+    }
+  }
+
+  UserEntity toEntity() {
+    return switch (this) {
+      final AuthenticatedUserData value => UserEntity(
+        id: value.id,
+        email: value.email,
+        name: value.name ?? '',
+        onboarded: value.onboarded,
+        avatarPath: value.avatarPath,
+        creationDate: value.creationDate,
+        lastUpdateDate: value.lastUpdateDate,
+      ),
+      final AnonymousUserData value => UserEntity(
+        id: value.id,
+        name: '',
+        onboarded: value.onboarded,
+        creationDate: value.creationDate,
+        lastUpdateDate: value.lastUpdateDate,
+      ),
+      LoadingUserData() => throw "user is not connected",
+    };
+  }
+
+  String get idOrThrow => switch (this) {
+    AuthenticatedUserData(:final id) => id!,
+    AnonymousUserData(:final id) => id!,
+    LoadingUserData() => throw "user is not connected",
+  };
+
+  String? get idOrNull => switch (this) {
+    AuthenticatedUserData(:final id) => id,
+    AnonymousUserData(:final id) => id,
+    LoadingUserData() => null,
+  };
+
+  bool get isLoading => switch (this) {
+    AuthenticatedUserData() => false,
+    AnonymousUserData() => false,
+    LoadingUserData() => true,
+  };
+
+  bool get isOnboarded => switch (this) {
+    AuthenticatedUserData(:final onboarded) => onboarded,
+    AnonymousUserData(:final onboarded) => onboarded ?? false,
+    LoadingUserData() => false,
+  };
+}

package/templates/firebase/lib/core/data/repositories/user_repository.dart

@@ -0,0 +1,130 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/data/api/image.dart';
+import 'package:kasy_kit/core/data/api/user_api.dart';
+import 'package:kasy_kit/core/data/entities/upload_result.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/features/subscription/repositories/subscription_repository.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+import 'package:logger/logger.dart';
+
+final userRepositoryProvider = Provider<UserRepository>(
+  (ref) => UserRepository(
+    userApi: ref.read(userApiProvider),
+    subscriptionRepository: ref.read(subscriptionRepositoryProvider),
+  ),
+);
+
+class UserRepository {
+  final UserApi _userApi;
+  final SubscriptionRepository _subscriptionRepository;
+
+
+  UserRepository({
+    required UserApi userApi,
+    required SubscriptionRepository subscriptionRepository,
+  }) : _subscriptionRepository = subscriptionRepository, _userApi = userApi;
+
+  Future<User?> get(String id) async {
+    var userEntity = await _userApi.get(id);
+    if (userEntity == null) {
+      return null;
+    }
+    try {
+      // We set the user id to RevenueCat BEFORE getting the subscription
+      // so that getEntitlements() in the RC fallback uses the correct user
+      await _subscriptionRepository.initUser(id);
+      // We get the subscription of the user and return it with the user
+      final subscription = await _subscriptionRepository.get(id);
+      // We update the user locale if it's different from the current locale
+      userEntity = await _updateUserLocale(userEntity);
+      // We return the user with the subscription
+      final user = User.fromEntity(userEntity);
+      return switch (user) {
+        final AuthenticatedUserData value => value.copyWith(
+          subscription: subscription,
+        ),
+        final AnonymousUserData value => value.copyWith(
+          subscription: subscription,
+        ),
+        _ => null,
+      };
+    } catch (e) {
+      // We catch the error to avoid blocking the user if the subscription is not available
+      // On most case it's because you didn't yet setup the RevenueCat api key
+      Logger().e('Error while getting subscription');
+      // We return the user without the subscription
+      return User.fromEntity(userEntity);
+    }
+  }
+
+  /// We updates the user avatar
+  /// We convert the image to jpeg and resize it to 300px width
+  /// and 80% quality to reduce the size of the image
+  /// Most of the current phones makes pictures with a width of 3000px.
+  /// That can take a lot of time and bandwidth to upload.
+  /// We then upload the image
+  Stream<UploadResult> saveAvatar({
+    required String userId,
+    required Uint8List data,
+  }) async* {
+    final jpgData = await compute(
+      imgToJpeg,
+      JpegParams(data: data, maxWidth: 450, quality: 80),
+    );
+    yield* _userApi.updateAvatar(
+      userId,
+      jpgData,
+    );
+  }
+
+  Future<void> deleteAvatar({required String userId}) {
+    return _userApi.deleteAvatar(userId);
+  }
+
+  /// Update the email and optionally the display name of a user in Firestore.
+  /// Called after linking a social provider to an anonymous account so that the
+  /// Firestore document reflects the authenticated identity.
+  Future<void> updateEmailAndName({
+    required String userId,
+    required String email,
+    String? name,
+  }) async {
+    final entity = UserEntity(id: userId, email: email, name: name);
+    await _userApi.update(entity);
+  }
+
+  Future<User> setOnboarded(User user) async {
+    final userCpy = switch(user) {
+      final AuthenticatedUserData value => value.copyWith(onboarded: true),
+      final AnonymousUserData value => value.copyWith(onboarded: true),
+      _ => throw Exception('User not found'),
+    };
+
+    await _userApi.update(userCpy.toEntity());
+    return userCpy;
+  }
+
+  /// 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.
+  Future<void> delete() async {
+    await _userApi.deleteMe();
+  }
+
+  /// We update the user locale
+  /// We update the locale in the user entity
+  /// and in the database if it's different from the current locale
+  /// We return the updated user entity
+  /// -- Locale is not used within the User 
+  /// -- The locale is only used for sending notifications to the user with the correct language
+  /// -- on app we can use LocaleSettings.instance.currentLocale to get the current locale
+  Future<UserEntity> _updateUserLocale(UserEntity userEntity) async {
+    final currentLocale = LocaleSettings.instance.currentLocale;
+    if (userEntity.locale == currentLocale.languageCode) {
+      return userEntity;
+    }
+    await _userApi.updateLocale(userEntity.id!, currentLocale.languageCode);
+    return userEntity.copyWith(locale: currentLocale.languageCode);
+  }
+}