feat: sign user out after 2 hours/Never

lib/core/strings.dart

@@ -279,6 +279,7 @@ abstract final class Strings {
   static const deleteAccount = 'Delete account';
   static const credits = 'Credits';
   static const privacyPolicy = 'Privacy policy';
+  static const sessionTimeout = 'Session timeout';
 
   static const emailShimmerText = '[email protected]';
   static const openingHoursShimmerText = 'Somedays: 8-16';

lib/core/widgets/components/dropdown.dart

@@ -2,17 +2,21 @@ import 'package:coffeecard/core/styles/app_colors.dart';
 import 'package:coffeecard/core/styles/app_text_styles.dart';
 import 'package:flutter/material.dart';
 
-class Dropdown<FilterCategory> extends StatelessWidget {
+class Dropdown<T> extends StatelessWidget {
   final bool loading;
-  final FilterCategory value;
-  final List<DropdownMenuItem<FilterCategory>>? items;
-  final void Function(FilterCategory?) onChanged;
+  final T value;
+  final List<DropdownMenuItem<T>> items;
+  final void Function(T?) onChanged;
+  final TextStyle? textStyle;
+  final Color? dropdownColor;
 
   const Dropdown({
     required this.loading,
     required this.value,
     required this.items,
     required this.onChanged,
+    this.textStyle,
+    this.dropdownColor,
   });
 
   Container get _underline {
@@ -29,17 +33,18 @@ class Dropdown<FilterCategory> extends StatelessWidget {
     );
   }
 
-  Color get _color => loading ? AppColors.lightGray : AppColors.white;
+  Color get _color =>
+      loading ? AppColors.lightGray : (dropdownColor ?? AppColors.white);
 
   @override
   Widget build(BuildContext context) {
     return Theme(
       data: ThemeData(disabledColor: AppColors.lightGray),
       child: DropdownButton(
-        dropdownColor: AppColors.secondary,
+        dropdownColor: dropdownColor ?? AppColors.secondary,
         underline: _underline,
         icon: Icon(Icons.arrow_drop_down, color: _color),
-        style: AppTextStyle.buttonText,
+        style: textStyle ?? AppTextStyle.buttonText,
         value: value,
         items: items,
         onChanged: loading ? null : onChanged,

lib/features/authentication/presentation/cubits/authentication_cubit.dart

@@ -1,9 +1,13 @@
+import 'package:coffeecard/core/external/date_service.dart';
 import 'package:coffeecard/features/authentication/domain/entities/authenticated_user.dart';
 import 'package:coffeecard/features/authentication/domain/usecases/clear_authenticated_user.dart';
 import 'package:coffeecard/features/authentication/domain/usecases/get_authenticated_user.dart';
 import 'package:coffeecard/features/authentication/domain/usecases/save_authenticated_user.dart';
+import 'package:coffeecard/features/session/domain/usecases/get_session_details.dart';
+import 'package:coffeecard/features/session/domain/usecases/save_session_details.dart';
 import 'package:equatable/equatable.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:fpdart/fpdart.dart';
 
 part 'authentication_state.dart';
 
@@ -14,20 +18,65 @@
   final ClearAuthenticatedUser clearAuthenticatedUser;
   final SaveAuthenticatedUser saveAuthenticatedUser;
   final GetAuthenticatedUser getAuthenticatedUser;
+  final GetSessionDetails getSessionDetails;
+  final SaveSessionDetails saveSessionDetails;
+  final DateService dateService;
 
   AuthenticationCubit({
     required this.clearAuthenticatedUser,
     required this.saveAuthenticatedUser,
     required this.getAuthenticatedUser,
+    required this.getSessionDetails,
+    required this.saveSessionDetails,
+    required this.dateService,
   }) : super(const AuthenticationState._());
 
   Future<void> appStarted() async {
     final authenticatedUser = await getAuthenticatedUser();
 
     authenticatedUser.match(
       () => emit(const AuthenticationState.unauthenticated()),
-      (authenticatedUser) =>
-          emit(AuthenticationState.authenticated(authenticatedUser)),
+      (authenticatedUser) async {
+        final sessionDetails = await getSessionDetails();
+
+        sessionDetails.match(
+          () => emit(AuthenticationState.authenticated(authenticatedUser)),
+          (sessionDetails) async {
+            final sessionExpired = _isSessionExpired(
+              sessionDetails.lastLogin,
+              sessionDetails.sessionTimeout,
+            );
+
+            if (sessionExpired) {
+              await unauthenticated();
+              return;
+            }
+
+            emit(AuthenticationState.authenticated(authenticatedUser));
+          },
+        );
+      },
+    );
+  }
+
+  bool _isSessionExpired(
+    Option<DateTime> lastLogin,
+    Option<Duration?> sessionTimeout,
+  ) {
+    return lastLogin.match(
+      () => false,
+      (lastLogin) => sessionTimeout.match(
+        () => false,
+        (sessionTimeout) {
+          if (sessionTimeout == null) {
+            return false;
+          }
+
+          final now = dateService.currentDateTime;
+          final difference = now.difference(lastLogin);
+          return difference > sessionTimeout;
+        },
+      ),
     );
   }
 
@@ -42,6 +91,20 @@
       encodedPasscode: encodedPasscode,
     );
 
+    final sessionDetails = await getSessionDetails();
+
+    final now = some(dateService.currentDateTime);
+    sessionDetails.match(
+      () async => await saveSessionDetails(
+        lastLogin: now,
+        sessionTimeout: none(),
+      ),
+      (sessionDetails) async => await saveSessionDetails(
+        lastLogin: now,
+        sessionTimeout: sessionDetails.sessionTimeout,
+      ),
+    );
+
     emit(
       AuthenticationState.authenticated(
         AuthenticatedUser(
@@ -55,6 +118,20 @@
 
   Future<void> unauthenticated() async {
     await clearAuthenticatedUser();
+
+    final sessionDetails = await getSessionDetails();
+
+    sessionDetails.match(
+      () async => await saveSessionDetails(
+        lastLogin: none(),
+        sessionTimeout: none(),
+      ),
+      (sessionDetails) async => await saveSessionDetails(
+        lastLogin: none(),
+        sessionTimeout: sessionDetails.sessionTimeout,
+      ),
+    );
+
     emit(const AuthenticationState.unauthenticated());
   }
 }

lib/features/authentication/presentation/cubits/authentication_state.dart

@@ -32,7 +32,11 @@ class AuthenticationState extends Equatable {
   }
 }
 
-enum AuthenticationStatus { unknown, authenticated, unauthenticated }
+enum AuthenticationStatus {
+  unknown,
+  authenticated,
+  unauthenticated,
+}
 
 extension AuthenticationStatusIs on AuthenticationStatus {
   bool get isUnknown => this == AuthenticationStatus.unknown;

lib/features/redirection/redirection_router.dart

@@ -103,8 +103,7 @@ class _MainRedirectionRouterState extends State<MainRedirectionRouter> {
   /// Redirects the user to the login page based.
   /// The route (animation) is determined by the [firstNavigation] flag.
   void redirectToLogin() {
-    final Route route;
-    route = firstNavigation
+    final route = firstNavigation
         ? LoginPageEmail.routeFromSplash
         : LoginPageEmail.routeFromLogout;
 

lib/features/session/data/datasources/session_local_data_source.dart

@@ -0,0 +1,41 @@
+import 'dart:convert';
+
+import 'package:coffeecard/features/session/data/models/session_details_model.dart';
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:fpdart/fpdart.dart';
+import 'package:logger/logger.dart';
+
+class SessionLocalDataSource {
+  static const _sessionKey = 'session';
+
+  final FlutterSecureStorage storage;
+  final Logger logger;
+
+  const SessionLocalDataSource({
+    required this.storage,
+    required this.logger,
+  });
+
+  Future<void> saveSessionDetails(SessionDetailsModel sessionDetails) async {
+    await storage.write(
+      key: _sessionKey,
+      value: json.encode(sessionDetails),
+    );
+
+    logger.d('$sessionDetails added to storage');
+  }
+
+  Future<Option<SessionDetailsModel>> getSessionDetails() async {
+    final jsonString = await storage.read(key: _sessionKey);
+
+    if (jsonString == null) {
+      return none();
+    }
+
+    final sessionDetails = SessionDetailsModel.fromJson(
+      json.decode(jsonString) as Map<String, dynamic>,
+    );
+
+    return some(sessionDetails);
+  }
+}

lib/features/session/data/models/session_details_model.dart

@@ -0,0 +1,55 @@
+import 'package:coffeecard/features/session/domain/entities/session_details.dart';
+import 'package:fpdart/fpdart.dart';
+
+class SessionDetailsModel extends SessionDetails {
+  const SessionDetailsModel({
+    required super.sessionTimeout,
+    required super.lastLogin,
+  });
+
+  factory SessionDetailsModel.fromJson(Map<String, dynamic> json) {
+    return SessionDetailsModel(
+      sessionTimeout: _parseOption(json, 'session_timeout', _parseDuration),
+      lastLogin: _parseOption(json, 'last_login', DateTime.parse),
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'last_login': _optionToString(lastLogin),
+      'session_timeout': _optionToString(sessionTimeout),
+    };
+  }
+
+  static String? _optionToString<T>(Option<T> option) {
+    return option.match(() => 'null', (value) => value.toString());
+  }
+
+  static Option<T> _parseOption<T>(
+    Map<String, dynamic> jsonMap,
+    String key,
+    T Function(String) callback,
+  ) {
+    if (!jsonMap.containsKey(key)) {
+      return none();
+    }
+
+    final val = jsonMap[key] as String;
+
+    if (val == 'null') {
+      return none();
+    }
+
+    return Some(callback(val));
+  }
+
+  static Duration _parseDuration(String duration) {
+    final parts = duration.split(':');
+
+    final hours = int.parse(parts[0]);
+    final minutes = int.parse(parts[1]);
+    final seconds = int.parse(parts[2].split('.')[0]);
+
+    return Duration(hours: hours, minutes: minutes, seconds: seconds);
+  }
+}

lib/features/session/domain/entities/session_details.dart

@@ -0,0 +1,12 @@
+import 'package:equatable/equatable.dart';
+import 'package:fpdart/fpdart.dart';
+
+class SessionDetails extends Equatable {
+  final Option<Duration?> sessionTimeout;
+  final Option<DateTime> lastLogin;
+
+  const SessionDetails({required this.sessionTimeout, required this.lastLogin});
+
+  @override
+  List<Object?> get props => [sessionTimeout, lastLogin];
+}

lib/features/session/domain/usecases/get_session_details.dart

@@ -0,0 +1,13 @@
+import 'package:coffeecard/features/session/data/datasources/session_local_data_source.dart';
+import 'package:coffeecard/features/session/domain/entities/session_details.dart';
+import 'package:fpdart/fpdart.dart';
+
+class GetSessionDetails {
+  final SessionLocalDataSource dataSource;
+
+  GetSessionDetails({required this.dataSource});
+
+  Future<Option<SessionDetails>> call() {
+    return dataSource.getSessionDetails();
+  }
+}

lib/features/session/domain/usecases/save_session_details.dart

@@ -0,0 +1,18 @@
+import 'package:coffeecard/features/session/data/datasources/session_local_data_source.dart';
+import 'package:coffeecard/features/session/data/models/session_details_model.dart';
+import 'package:fpdart/fpdart.dart';
+
+class SaveSessionDetails {
+  final SessionLocalDataSource dataSource;
+
+  SaveSessionDetails({required this.dataSource});
+
+  Future<void> call({
+    required Option<Duration?> sessionTimeout,
+    required Option<DateTime> lastLogin,
+  }) async {
+    return dataSource.saveSessionDetails(
+      SessionDetailsModel(sessionTimeout: sessionTimeout, lastLogin: lastLogin),
+    );
+  }
+}