kasy-cli 1.2.1

package/lib/scaffold/backends/api/patch/lib/features/notifications/api/notifications_api.dart

@@ -0,0 +1,333 @@
+import 'dart:convert';
+
+import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/notifications/api/entities/notifications_entity.dart';
+import 'package:dio/dio.dart';
+import 'package:firebase_messaging/firebase_messaging.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+final notificationsApiProvider = Provider<NotificationsApi>(
+  (ref) => FirebaseNotificationsApi(
+    messaging: FirebaseMessaging.instance,
+    logger: Logger(),
+    client: ref.read(httpClientProvider),
+  ),
+);
+
+/// This class is responsible for listening from firebase notifications
+/// As I like repositories to not depend on external libraries
+/// I wrapped some of the firebase messaging methods
+///
+/// You could use directly the firebase messaging methods but making a fake implementation
+/// of this class would be harder.
+abstract class NotificationsApi {
+  /// Request permission to receive notifications
+  Future<void> requestPermission();
+
+  // Used to listen to notifications when the app is in foreground
+  void setForegroundHandler(OnRemoteMessage handler);
+
+  // Used to listen to notifications when the app is in background
+  void setBackgroundHandler(OnRemoteMessage handler);
+
+  // Used to listen to notifications when user clicks on the notification
+  void setOnOpenNotificationHandler(OnRemoteMessage handler);
+
+  // Used to get the initial message from the app 
+  // (notification opened when the app is not ready)
+  Future<RemoteMessage?> getInitialMessage();
+
+  // Used to get the past notifications from the server
+  Future<List<NotificationEntity>> get(
+    String userId, {
+    DateTime? startDate,
+    required int limit,
+    int page = 0,
+  });
+
+  // Used to mark a notification as read
+  Future<void> read(String userId, String notificationId);
+
+  // Used to get the unread notifications count
+  Stream<int> unreadNotifications(String userId);
+
+  // Used to register to a topic
+  void registerTopic(String topic);
+
+  // Used to unregister from a topic
+  void unregisterTopic(String topic);
+
+  // Used to get the permission status
+  Future<PermissionStatus> getPermissionStatus();
+
+  // Admin: find a user's ID by their email address
+  Future<String?> findUserByEmail(String email);
+
+  // Admin: create a notification for a specific user
+  Future<void> sendNotification(
+    String userId, {
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  });
+
+  // Admin: send a notification to a list of emails
+  Future<void> sendNotificationToEmails(
+    List<String> emails, {
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  });
+
+  // Admin: create a notification for every registered user
+  Future<void> sendNotificationToAll({
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  });
+}
+
+typedef OnRemoteMessage = Future<void> Function(RemoteMessage message);
+
+class FirebaseNotificationsApi implements NotificationsApi {
+  final FirebaseMessaging _messaging;
+  final HttpClient _client;
+  final Logger _logger;
+
+  FirebaseNotificationsApi({
+    required FirebaseMessaging messaging,
+    required HttpClient client,
+    required Logger logger,
+  })  : _messaging = messaging,
+        _client = client,
+        _logger = logger;
+
+  @override
+  Future<void> requestPermission() async {
+    try {
+      await _messaging.requestPermission();
+    } catch (e) {
+      _logger.e(e);
+    }
+  }
+
+  @override
+  void setForegroundHandler(OnRemoteMessage handler) {
+    FirebaseMessaging.onMessage.listen(handler);
+  }
+
+  @override
+  void setBackgroundHandler(OnRemoteMessage handler) {
+    FirebaseMessaging.onBackgroundMessage(handler);
+  }
+
+  @override
+  void setOnOpenNotificationHandler(OnRemoteMessage handler) {
+    FirebaseMessaging.onMessageOpenedApp.listen(handler);
+  }
+
+  @override
+  Future<RemoteMessage?> getInitialMessage() {
+    return _messaging.getInitialMessage();
+  }
+
+  @override
+  void registerTopic(String topic) {
+    _messaging.subscribeToTopic(topic);
+  }
+
+  @override
+  void unregisterTopic(String topic) {
+    _messaging.unsubscribeFromTopic(topic);
+  }
+
+  @override
+  Future<List<NotificationEntity>> get(
+    String userId, {
+    DateTime? startDate,
+    required int limit,
+    int page = 0,
+  }) async {
+    try {
+      final response = await _client.get(
+        '/users/$userId/notifications',
+        queryParameters: {
+          'page': page,
+          'pageSize': limit,
+        },
+      );
+      if (response.data == null) {
+        return [];
+      }
+      final data = response.data! as List<dynamic>;
+      return data
+          .map((e) => NotificationEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, stacktrace) {
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
+  @override
+  Future<void> read(String userId, String notificationId) async {
+    try {
+      final _ = await _client.put(
+        '/users/$userId/notifications/$notificationId',
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, stacktrace) {
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
+  @override
+  Stream<int> unreadNotifications(String userId) async* {
+    try {
+      final response = await _client.get<ResponseBody>(
+        '/users/$userId/notifications/unread',
+        options: Options(
+          responseType: ResponseType.stream,
+        ),
+      );
+      yield* utf8.decoder
+          .bind(response.data!.stream)
+          .map((line) => jsonDecode(line))
+          .map(
+        (event) {
+          final list = event as List<dynamic>;
+          final lastItem = list.lastOrNull;
+          if (list.isEmpty || lastItem == null) {
+            return 0;
+          }
+          // ignore: avoid_dynamic_calls
+          return lastItem['count'] as int; // this is for demo purposes
+        },
+      );
+    } on DioException catch (e, stacktrace) {
+      debugPrint('$e: $stacktrace');
+      throw ApiError.fromDioException(e);
+    } catch (e, stacktrace) {
+      debugPrint('$e: $stacktrace');
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
+  @override
+  Future<PermissionStatus> getPermissionStatus() {
+    return Permission.notification.status;
+  }
+
+  @override
+  Future<String?> findUserByEmail(String email) async {
+    try {
+      final response = await _client.get(
+        '/users',
+        queryParameters: {'email': email},
+      );
+      if (response.data == null) return null;
+      final data = response.data as List<dynamic>;
+      if (data.isEmpty) return null;
+      return (data.first as Map<String, dynamic>)['id'] as String?;
+    } on DioException catch (e) {
+      _logger.e('findUserByEmail error: $e');
+      return null;
+    } catch (e, s) {
+      _logger.e('findUserByEmail error: $e: $s');
+      return null;
+    }
+  }
+
+  @override
+  Future<void> sendNotification(
+    String userId, {
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  }) async {
+    try {
+      await _client.post(
+        '/users/$userId/notifications',
+        data: {
+          'title': title,
+          'body': body,
+          if (imageUrl != null && imageUrl.isNotEmpty) 'image_url': imageUrl,
+          if (route != null && route.isNotEmpty) 'data': {'route': route},
+          'type': 'OTHER',
+        },
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    }
+  }
+
+  @override
+  Future<void> sendNotificationToEmails(
+    List<String> emails, {
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  }) async {
+    final notFound = <String>[];
+    for (final email in emails) {
+      final userId = await findUserByEmail(email.trim());
+      if (userId == null) {
+        notFound.add(email.trim());
+      } else {
+        await sendNotification(userId, title: title, body: body, imageUrl: imageUrl, route: route);
+      }
+    }
+    if (notFound.isNotEmpty) throw UsersNotFoundError(notFound.join(', '));
+  }
+
+  @override
+  Future<void> sendNotificationToAll({
+    required String title,
+    required String body,
+    String? imageUrl,
+    String? route,
+  }) async {
+    try {
+      await _client.post(
+        '/notifications/broadcast',
+        data: {
+          'title': title,
+          'body': body,
+          if (imageUrl != null && imageUrl.isNotEmpty) 'image_url': imageUrl,
+          if (route != null && route.isNotEmpty) 'data': {'route': route},
+          'type': 'OTHER',
+        },
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    }
+  }
+}
+
+class UsersNotFoundError implements Exception {
+  final String emails;
+  const UsersNotFoundError(this.emails);
+
+  @override
+  String toString() => emails;
+}

package/lib/scaffold/backends/api/patch/lib/features/notifications/providers/models/notification.dart

@@ -0,0 +1,185 @@
+// ignore_for_file: invalid_annotation_target, constant_identifier_names
+
+import 'package:kasy_kit/features/notifications/api/entities/notifications_entity.dart';
+import 'package:kasy_kit/features/notifications/api/local_notifier.dart';
+import 'package:kasy_kit/features/notifications/repositories/notifications_repository.dart';
+import 'package:go_router/go_router.dart';
+import 'package:kasy_kit/router.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:logger/logger.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:sentry_flutter/sentry_flutter.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+part 'notification.freezed.dart';
+part 'notification.g.dart';
+
+@freezed
+sealed class Notification with _$Notification {
+  const Notification._();
+
+  const factory Notification.withData({
+    String? id,
+    required String title,
+    required String body,
+    required DateTime createdAt,
+    DateTime? readAt,
+    String? imageUrl,
+    @JsonKey(includeFromJson: false, includeToJson: false)
+    LocalNotifier? notifier,
+    @JsonKey(includeFromJson: false, includeToJson: false)
+    NotificationSettings? notifierSettings,
+    NotificationTypes? type,
+    Map<String, dynamic>? data,
+  }) = NotificationData;
+
+  factory Notification.fromJson(Map<String, dynamic> json) =>
+      _$NotificationFromJson(json);
+
+  factory Notification.from(
+    Map<String, dynamic> json, {
+    String? id,
+    Map<String, dynamic>? data,
+    LocalNotifier? notifierApi,
+    NotificationSettings? notifierSettings,
+  }) =>
+      Notification.withData(
+        id: id,
+        title: json['title'] as String,
+        body: json['body'] as String,
+        imageUrl: json['image'] as String?,
+        type: data != null && data.containsKey('type')
+            ? NotificationTypes.values.firstWhere(
+                (e) => e.name == data['type'],
+                orElse: () => NotificationTypes.OTHER,
+              )
+            : null,
+        data: data,
+        createdAt: DateTime.now(),
+        notifier: notifierApi,
+        notifierSettings: notifierSettings,
+      );
+
+  Future<void> show({NotificationSettings? settings}) async {
+    if (notifier == null) {
+      throw Exception(
+        'You must provide a LocalNotifierApi to show a notification',
+      );
+    }
+    if (notifierSettings != null) {
+      await notifier!.show(notifierSettings!, this);
+      return;
+    } else if (settings != null) {
+      await notifier!.show(settings, this);
+      return;
+    }
+    throw Exception(
+      'You must provide a NotificationSettings to show a notification',
+    );
+  }
+
+  bool get seen => readAt != null;
+
+  Future<void> onTap() async {
+    // if the app is not ready, we store the notification in the pending notification handler
+    if (navigatorKey.currentContext == null) {
+      return;
+    }
+
+    // Open external URL
+    if (type == NotificationTypes.LINK && data?.containsKey('url') == true) {
+      try {
+        launchUrl(Uri.parse(data!['url'] as String));
+      } catch (e, s) {
+        Logger().e("error $e");
+        Sentry.captureException(e, stackTrace: s);
+      }
+      return;
+    }
+    // Navigate to an internal route sent in the notification data.
+    // Example: data: {"route": "/premium"} → opens the premium page.
+    if (data?.containsKey('route') == true) {
+      final route = data!['route'] as String;
+      navigatorKey.currentContext!.go(route);
+      return;
+    }
+    // Default: open the notifications list
+    navigatorKey.currentContext!.go('/notifications');
+  }
+}
+
+sealed class NotificationPermission {
+  /// ask for permission if needed
+  Future<void> maybeAsk() async {
+    final permission = this;
+    switch (permission) {
+      case NotificationPermissionWaiting():
+        await permission.ask();
+      case NotificationPermissionDenied():
+        await permission.ask();
+      case NotificationPermissionGranted():
+      default:
+    }
+  }
+}
+
+/// we asked for permission and it was granted
+class NotificationPermissionGranted extends NotificationPermission {
+  NotificationPermissionGranted();
+}
+
+/// we asked for permission and it was denied
+class NotificationPermissionDenied extends NotificationPermission {
+  final NotificationSettings? _notificationSettings;
+  final NotificationsRepository? _repository;
+
+  NotificationPermissionDenied({
+    NotificationSettings? notificationSettings,
+    NotificationsRepository? repository,
+  })  : _repository = repository,
+        _notificationSettings = notificationSettings;
+
+  Future<void> ask() async {
+    if (_notificationSettings == null) {
+      throw Exception("NotificationsApi is null");
+    }
+    final granted = await _notificationSettings.askPermission();
+    NotificationPermission? permission;
+    if (granted) {
+      permission = NotificationPermissionGranted();
+    } else {
+      permission = NotificationPermissionDenied();
+    }
+    await _repository!.init();
+  }
+
+  Future<void> openSettings() async {
+    await openAppSettings();
+  }
+}
+
+/// we never asked for permission
+class NotificationPermissionWaiting extends NotificationPermission {
+  final NotificationSettings? _notificationSettings;
+  final NotificationsRepository? _repository;
+
+  NotificationPermissionWaiting({
+    NotificationSettings? notificationSettings,
+    NotificationsRepository? repository,
+  })  : _notificationSettings = notificationSettings,
+        _repository = repository;
+
+  Future<void> ask() async {
+    if (_notificationSettings == null) {
+      throw Exception("NotificationsApi is null");
+    }
+    final granted = await _notificationSettings.askPermission();
+    NotificationPermission? permission;
+    if (granted) {
+      permission = NotificationPermissionGranted();
+      await _repository?.init();
+    } else {
+      permission = NotificationPermissionDenied();
+    }
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/onboarding/api/entities/user_info_entity.dart

@@ -0,0 +1,26 @@
+// ignore: depend_on_referenced_packages
+// ignore_for_file: invalid_annotation_target
+
+
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'user_info_entity.freezed.dart';
+part 'user_info_entity.g.dart';
+
+
+
+@freezed
+sealed class UserInfoEntity with _$UserInfoEntity {
+  const factory UserInfoEntity({
+    @JsonKey(includeIfNull: false) String? id,
+    @JsonKey(name: 'user_id') required String userId,
+    @JsonKey(name: 'key') required String key,
+    @JsonKey(name: 'value') required String value,
+  }) = SubscriptionEntityData;
+
+  factory UserInfoEntity.fromJson(Map<String, Object?> json) =>
+      _$UserInfoEntityFromJson(json);
+}
+
+

package/lib/scaffold/backends/api/patch/lib/features/onboarding/api/user_infos_api.dart

@@ -0,0 +1,107 @@
+import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/onboarding/api/entities/user_info_entity.dart';
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+
+final userInfosApiProvider = Provider(
+  (ref) => UserInfosApi(
+    client: ref.read(httpClientProvider),
+  ),
+);
+
+class UserInfosApi {
+  final HttpClient _client;
+  final Logger _logger = Logger();
+
+  UserInfosApi({
+    required HttpClient client,
+  }) : _client = client;
+
+  Future<List<UserInfoEntity>> getAll(String userId) async {
+    try {
+      final response = await _client.get('/users/$userId/infos');
+      // final json = jsonDecode(response.data) as Map<String, dynamic>;
+      if (response.data == null) {
+        return [];
+      }
+      final data = response.data! as List<dynamic>;
+      return data
+          .map((e) => UserInfoEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e, stackTrace) {
+      _logger.e(
+        "Error while getting user subscription from backend: $e",
+        stackTrace: stackTrace,
+      );
+      throw ApiError.fromDioException(e);
+    } catch (e) {
+      _logger.e(e);
+      throw ApiError(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  Future<UserInfoEntity?> getByKey(String userId, String key) async {
+    try {
+      final response = await _client.get(
+        '/users/$userId/infos',
+        queryParameters: {
+          'key': key,
+        },
+      );
+      return UserInfoEntity.fromJson(response.data as Map<String, dynamic>);
+    } on DioException catch (e, stackTrace) {
+      _logger.e(
+        "Error while getting user subscription from backend: $e",
+        stackTrace: stackTrace,
+      );
+      throw ApiError.fromDioException(e);
+    } catch (e) {
+      _logger.e(e);
+      throw ApiError(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  Future<void> create(String userId, UserInfoEntity info) async {
+    try {
+      await _client.post('/users/$userId/infos', data: info.toJson());
+    } on DioException catch (e, stackTrace) {
+      _logger.e(
+        "Error while getting user subscription from backend: $e",
+        stackTrace: stackTrace,
+      );
+      throw ApiError.fromDioException(e);
+    } catch (e) {
+      _logger.e(e);
+      throw ApiError(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  Future<void> update(String userId, UserInfoEntity info) async {
+    try {
+      await _client.put('/users/$userId/infos/${info.id}', data: info.toJson());
+    } on DioException catch (e, stackTrace) {
+      _logger.e(
+        "Error while getting user subscription from backend: $e",
+        stackTrace: stackTrace,
+      );
+      throw ApiError.fromDioException(e);
+    } catch (e) {
+      _logger.e(e);
+      throw ApiError(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+}