Daily commit

lib/bloc/authentication/auth_bloc.dart

@@ -0,0 +1,82 @@
+import 'package:app_gaslieferung/bloc/authentication/auth_event.dart';
+import 'package:app_gaslieferung/bloc/authentication/auth_state.dart';
+import 'package:app_gaslieferung/bloc/message_wrapper/message_bloc.dart';
+import 'package:app_gaslieferung/bloc/message_wrapper/message_event.dart';
+import 'package:app_links/app_links.dart';
+import 'package:bloc/bloc.dart';
+import 'package:flutter/cupertino.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+import '../../exceptions/login.dart';
+import '../../util/login.dart';
+
+class AuthBloc extends Bloc<AuthEvent, AuthState> {
+  final _appLinks = AppLinks();
+  final MessageBloc msgBloc;
+  final String url;
+
+  AuthBloc({required this.url, required this.msgBloc}) : super(UnauthenticatedState()) {
+    on<AuthLoginEvent>(_onLoginEvent);
+    on<AuthLogoutEvent>(_onLogoutEvent);
+    on<AuthFailedEvent>(_onFailedEvent);
+    on<AuthLoginSuccessEvent>(_onLoginSuccessEvent);
+
+    _initDeepLinks();
+  }
+
+  void _initDeepLinks() async {
+    // Listen to the stream if any further deeplink is coming in.
+    _appLinks.uriLinkStream.listen((uri) {
+      _handleDeepLink(uri);
+    });
+  }
+
+  /// Handle Deeplink if login request is coming in.
+  void _handleDeepLink(Uri uri) {
+    if (state is UnauthenticatedState) {
+      try {
+        add(AuthLoginSuccessEvent(getSessionIdFromUrl(uri)));
+      } on LoginInvalidUrlException catch (e) {
+        msgBloc.add(MessageShow(message: e.toString()));
+      } on LoginNoSessionIdException catch (e) {
+        msgBloc.add(MessageShow(message: e.toString()));
+      } catch (e, st) {
+        debugPrint("Fehler beim Login. Stacktrace: $st");
+        debugPrint("Fehler beim Login. Message: $e");
+
+        add(
+          AuthFailedEvent(
+            message:
+            "Es ist ein unbekannter Fehler aufgetreten. Versuchen Sie es später erneut oder wenden Sie sich an die Zentrale.",
+          ),
+        );
+      }
+    } else {
+      // TODO: handle message if user is already logged in
+      debugPrint("NOT STATE");
+      debugPrint("$state");
+    }
+  }
+
+  void _onLoginSuccessEvent(
+    AuthLoginSuccessEvent event,
+    Emitter<AuthState> emit,
+  ) {
+    emit(AuthenticatedState(sessionId: event.sessionId));
+  }
+
+  void _onLoginEvent(AuthLoginEvent event, Emitter<AuthState> emit) async {
+    await launchUrl(
+      Uri.parse(url),
+      mode: LaunchMode.externalApplication,
+    );
+  }
+
+  void _onLogoutEvent(AuthLogoutEvent event, Emitter<AuthState> emit) {
+
+  }
+
+  void _onFailedEvent(AuthFailedEvent event, Emitter<AuthState> emit) {
+    emit(UnauthenticatedState());
+  }
+}

lib/bloc/authentication/auth_event.dart

@@ -0,0 +1,17 @@
+abstract class AuthEvent {}
+
+class AuthLoginEvent extends AuthEvent {}
+
+class AuthLoginSuccessEvent extends AuthEvent {
+  String sessionId;
+
+  AuthLoginSuccessEvent(this.sessionId);
+}
+
+class AuthLogoutEvent extends AuthEvent {}
+
+class AuthFailedEvent extends AuthEvent {
+  String message;
+
+  AuthFailedEvent({required this.message});
+}

lib/bloc/authentication/auth_state.dart

@@ -0,0 +1,17 @@
+abstract class AuthState {}
+
+class AuthInitialState extends AuthState {}
+
+class UnauthenticatedState extends AuthState {}
+
+class AuthenticatedState extends AuthState {
+  String sessionId;
+
+  AuthenticatedState({required this.sessionId});
+}
+
+class AuthFailedState extends AuthState {
+  String message;
+
+  AuthFailedState({required this.message});
+}

lib/bloc/message_wrapper/message_bloc.dart

@@ -0,0 +1,21 @@
+import 'package:bloc/bloc.dart';
+
+import 'message_event.dart';
+import 'message_state.dart';
+
+class MessageBloc extends Bloc<MessageEvent, MessageState> {
+  MessageBloc() : super(MessageInitialState()) {
+    on<MessageShow>(_show);
+    on<MessageHide>(_hide);
+  }
+
+  void _show(MessageShow event, Emitter<MessageState> emit) async {
+    emit(MessageShowState(message: event.message));
+    await Future.delayed(event.duration);
+    emit(MessageHideState());
+  }
+
+  void _hide(MessageHide event, Emitter<MessageState> emit) {
+    emit(MessageHideState());
+  }
+}

lib/bloc/message_wrapper/message_event.dart

@@ -0,0 +1,10 @@
+abstract class MessageEvent {}
+
+class MessageShow extends MessageEvent {
+  String message;
+  Duration duration;
+
+  MessageShow({required this.message}) : duration = Duration(seconds: 5);
+}
+
+class MessageHide extends MessageEvent {}

lib/bloc/message_wrapper/message_state.dart

@@ -0,0 +1,7 @@
+abstract class MessageState {}
+class MessageInitialState extends MessageState {}
+class MessageShowState extends MessageState {
+  String message;
+  MessageShowState({required this.message});
+}
+class MessageHideState extends MessageState {}

lib/bloc/tour/tour_bloc.dart

@@ -0,0 +1,25 @@
+import 'package:app_gaslieferung/repository/tour_repository.dart';
+import 'package:bloc/bloc.dart';
+import 'package:flutter/cupertino.dart';
+
+import 'tour_event.dart';
+import 'tour_state.dart';
+
+class TourBloc extends Bloc<TourEvent, TourState> {
+  TourRepository tour;
+
+  TourBloc({required this.tour}) : super(TourInitial()) {
+    on<TourLoadEvent>(_onTourLoadEvent);
+  }
+
+  void _onTourLoadEvent(TourLoadEvent event, Emitter<TourState> emit) async {
+    emit(TourLoading());
+    try {
+      final tour = await this.tour.getTour(event.sessionId, event.carId);
+      emit(TourLoaded(tour: tour));
+    } catch (e, st) {
+      debugPrint(st.toString());
+      emit(TourLoadingFailed(message: e.toString()));
+    }
+  }
+}

lib/bloc/tour/tour_event.dart

@@ -0,0 +1,8 @@
+abstract class TourEvent {}
+
+class TourLoadEvent extends TourEvent {
+  String carId;
+  String sessionId;
+
+  TourLoadEvent({required this.carId, required this.sessionId});
+}

lib/bloc/tour/tour_state.dart

@@ -0,0 +1,20 @@
+import 'package:app_gaslieferung/model/delivery.dart';
+import 'package:app_gaslieferung/model/tour.dart';
+
+abstract class TourState {}
+
+class TourInitial extends TourState {}
+
+class TourLoaded extends TourState {
+  Tour tour;
+
+  TourLoaded({required this.tour});
+}
+
+class TourLoading extends TourState {}
+
+class TourLoadingFailed extends TourState {
+  String message;
+
+  TourLoadingFailed({required this.message});
+}

lib/bloc/tour_select/bloc.dart

@@ -1,14 +1,27 @@
-import 'package:app_gaslieferung/repository/tour_select_repository.dart';
+import 'package:app_gaslieferung/model/car.dart';
+import 'package:app_gaslieferung/repository/tour_repository.dart';
 import 'package:bloc/bloc.dart';
+import 'package:flutter/material.dart';
 import 'event.dart';
 import 'state.dart';
 
 class TourSelectBloc extends Bloc<TourSelectEvent, TourSelectState> {
-  TourSelectRepository repository;
+  TourRepository repository;
 
   TourSelectBloc({required this.repository}) : super(TourSelectInitial()) {
-    on<TourSelectEvent>((event, emit) {
-      // TODO: handle event
-    });
+    on<TourSelectLoadMetadataEvent>(_onTourSelectLoadCarsEvent);
   }
-}
+
+  void _onTourSelectLoadCarsEvent(
+    TourSelectLoadMetadataEvent event,
+    Emitter<TourSelectState> emit,
+  ) async {
+    emit(TourSelectLoading());
+    try {
+      emit(TourSelectLoaded(data: await repository.getSupplierTourMetadata(event.sessionId)));
+    } catch (e,st) {
+      debugPrint("Error on loading cars: $e\n$st");
+      emit(TourSelectError(message: "Es ist ein unbekannter Fehler aufgetreten. Versuchen Sie es erneut."));
+    }
+  }
+}

lib/bloc/tour_select/event.dart

@@ -1,5 +1,7 @@
 abstract class TourSelectEvent {}
 
-class TourSelectLoadingEvent extends TourSelectEvent {}
-class TourSelectLoadedEvent extends TourSelectEvent {}
-class TourSelectErrorEvent extends TourSelectEvent {}
+class TourSelectLoadMetadataEvent extends TourSelectEvent {
+  String sessionId;
+
+  TourSelectLoadMetadataEvent({required this.sessionId});
+}

lib/bloc/tour_select/state.dart

@@ -1,3 +1,19 @@
+import 'package:app_gaslieferung/model/supplier.dart';
+
 abstract class TourSelectState {}
 
-class TourSelectInitial extends TourSelectState {}
+class TourSelectInitial extends TourSelectState {}
+
+class TourSelectLoading extends TourSelectState {}
+
+class TourSelectLoaded extends TourSelectState {
+  SupplierTourMetadata data;
+
+  TourSelectLoaded({required this.data});
+}
+
+class TourSelectError extends TourSelectState {
+  String message;
+
+  TourSelectError({required this.message});
+}