score

lib/blocs/score_bloc/score_bloc.dart

@@ -3,23 +3,27 @@ import 'dart:developer';
 import 'package:equatable/equatable.dart';
 import 'package:score_repository/score_repository.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:user_repository/user_repository.dart';
 
 part 'score_event.dart';
 part 'score_state.dart';
 
 class ScoreBloc extends Bloc<ScoreEvent, ScoreState> {
-  final FirebaseScoreRepository _firebaseScoreRepository;
+  final FirebaseScoreRepository _scoreRepository;
+  final UserRepository _userRepository;
 
   ScoreBloc({
-    required FirebaseScoreRepository firebaseScoreRepository,
-  })  : _firebaseScoreRepository = firebaseScoreRepository,
+    required FirebaseScoreRepository scoreRepository,
+    required UserRepository userRepository,
+  })  : _scoreRepository = scoreRepository,
+        _userRepository = userRepository,
         super(ScoreInitial()) {
     try {
-      emit(ScoreSuccess(_firebaseScoreRepository.getReputation()));
+      emit(ScoreSuccess(_scoreRepository.getReputation()));
     } catch (e) {
       log(e.toString());
     }
-    _firebaseScoreRepository.streamReputation().listen((event) {
+    _scoreRepository.streamReputation().listen((event) {
       try {
         emit(ScoreSuccess(event));
       } catch (e) {
@@ -29,13 +33,91 @@ class ScoreBloc extends Bloc<ScoreEvent, ScoreState> {
     });
 
     on<SendScoreEvent>(_onSendScoreEvent);
+    on<LoadScoresForUserEvent>(_onLoadScoresForUserEvent);
+    on<LoadScoresForProfessionalEvent>(_onLoadScoresForProfessionalEvent);
   }
 
   void _onSendScoreEvent(SendScoreEvent event, Emitter<ScoreState> emit) async {
     try {
-      await _firebaseScoreRepository.addComment(event.comment);
+      await _scoreRepository.addComment(event.comment);
     } catch (e) {
       log(e.toString());
     }
   }
+
+  void _onLoadScoresForUserEvent(
+      LoadScoresForUserEvent event, Emitter<ScoreState> emit) async {
+    try {
+      final scoresStream = _scoreRepository.getScoresForUser(event.userId);
+
+      await for (var scores in scoresStream) {
+        if (scores.isEmpty) {
+          emit(const ScoresForUserLoaded([]));
+          return;
+        }
+        final userIds = scores.map((e) => e.authorId);
+
+        final List<MyUser> users =
+            await _userRepository.getUsersFromIds(userIds);
+
+        final usersDir = {for (var e in users) e.id: e};
+
+        final scoresInfo = scores.map((e) {
+          return ScoreInfoUI(
+            score: e,
+            user: usersDir[e.authorId]!,
+          );
+        }).toList();
+
+        log(scoresInfo.toString());
+
+        emit(ScoresForUserLoaded(scoresInfo));
+      }
+    } catch (e) {
+      log(e.toString());
+      emit(ScoreFailure());
+    }
+  }
+
+  void _onLoadScoresForProfessionalEvent(
+    LoadScoresForProfessionalEvent event,
+    Emitter<ScoreState> emit,
+  ) async {
+    try {
+      final scoresStream =
+          _scoreRepository.getScoresForProfessional(event.userId);
+
+      await for (var scores in scoresStream) {
+        if (scores.isEmpty) {
+          emit(const ScoresForUserLoaded([]));
+          return;
+        }
+        final userIds = scores.map((e) => e.authorId);
+
+        final List<MyUser> users =
+            await _userRepository.getUsersFromIds(userIds);
+
+        final usersDir = {for (var e in users) e.id: e};
+
+        final scoresInfo = scores.map((e) {
+          return ScoreInfoUI(
+            score: e,
+            user: usersDir[e.authorId]!,
+          );
+        }).toList();
+
+        emit(ScoresForUserLoaded(scoresInfo));
+      }
+    } catch (e) {
+      log(e.toString());
+      emit(ScoreFailure());
+    }
+  }
+}
+
+class ScoreInfoUI {
+  final CommentEntity score;
+  final MyUser user;
+
+  ScoreInfoUI({required this.score, required this.user});
 }

lib/blocs/score_bloc/score_event.dart

@@ -15,3 +15,21 @@ class SendScoreEvent extends ScoreEvent {
   @override
   List<Object> get props => [comment];
 }
+
+class LoadScoresForUserEvent extends ScoreEvent {
+  final String userId;
+
+  const LoadScoresForUserEvent({required this.userId});
+
+  @override
+  List<Object> get props => [userId];
+}
+
+class LoadScoresForProfessionalEvent extends ScoreEvent {
+  final String userId;
+
+  const LoadScoresForProfessionalEvent({required this.userId});
+
+  @override
+  List<Object> get props => [userId];
+}

lib/blocs/score_bloc/score_state.dart

@@ -20,3 +20,12 @@ class ScoreSuccess extends ScoreState {
   @override
   List<Object> get props => [reputation];
 }
+
+class ScoresForUserLoaded extends ScoreState {
+  final List<ScoreInfoUI> scores;
+
+  const ScoresForUserLoaded(this.scores);
+
+  @override
+  List<Object> get props => [scores];
+}