Merge branch 'main' into 2091-map-proposal-elements-for-testing

Author: emiride

catalyst_voices/apps/voices/lib/pages/overall_spaces/space/user_proposal_selectors/workspace_overview_proposal_selector.dart

@@ -28,7 +28,10 @@ class _WorkspaceDataProposalSelector extends StatelessWidget {
         BlocSelector<WorkspaceBloc, WorkspaceState,
             DataVisibilityState<List<Proposal>>>(
           selector: (state) {
-            return (data: state.notPublished, show: state.showProposals);
+            return (
+              data: state.notPublished,
+              show: state.showProposals && !state.isLoading
+            );
           },
           builder: (context, state) {
             return Offstage(

catalyst_voices/apps/voices/lib/pages/workspace/page/workspace_loading.dart

@@ -1,39 +1,28 @@
-import 'package:catalyst_voices/widgets/indicators/voices_circular_progress_indicator.dart';
+import 'package:catalyst_voices/widgets/indicators/voices_loading_overlay.dart';
 import 'package:catalyst_voices_blocs/catalyst_voices_blocs.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 
 class WorkspaceLoadingSelector extends StatelessWidget {
-  const WorkspaceLoadingSelector({super.key});
+  final Widget child;
+
+  const WorkspaceLoadingSelector({
+    super.key,
+    required this.child,
+  });
 
   @override
   Widget build(BuildContext context) {
     return BlocSelector<WorkspaceBloc, WorkspaceState, bool>(
       selector: (state) => state.isLoading,
-      builder: (context, state) {
-        return Offstage(
-          offstage: !state,
-          child: TickerMode(
-            enabled: state,
-            child: const _WorkspaceLoading(),
-          ),
+      builder: (context, isLoading) {
+        return Stack(
+          children: [
+            child,
+            VoicesLoadingOverlay(show: isLoading),
+          ],
         );
       },
     );
   }
 }
-
-class _WorkspaceLoading extends StatelessWidget {
-  const _WorkspaceLoading();
-
-  @override
-  Widget build(BuildContext context) {
-    return const Align(
-      alignment: Alignment.topCenter,
-      child: Padding(
-        padding: EdgeInsets.only(top: 32),
-        child: VoicesCircularProgressIndicator(),
-      ),
-    );
-  }
-}

catalyst_voices/apps/voices/lib/pages/workspace/page/workspace_page.dart

@@ -30,19 +30,20 @@ class _WorkspacePageState extends State<WorkspacePage>
   @override
   Widget build(BuildContext context) {
     return const Scaffold(
-      body: SingleChildScrollView(
-        child: Column(
-          children: [
-            WorkspaceHeader(),
-            Stack(
-              children: [
-                WorkspaceErrorSelector(),
-                WorkspaceLoadingSelector(),
-                WorkspaceUserProposalsSelector(),
-              ],
-            ),
-            SizedBox(height: 50),
-          ],
+      body: WorkspaceLoadingSelector(
+        child: SingleChildScrollView(
+          child: Column(
+            children: [
+              WorkspaceHeader(),
+              Stack(
+                children: [
+                  WorkspaceErrorSelector(),
+                  WorkspaceUserProposalsSelector(),
+                ],
+              ),
+              SizedBox(height: 50),
+            ],
+          ),
         ),
       ),
     );
@@ -72,6 +73,8 @@ class _WorkspacePageState extends State<WorkspacePage>
         );
       case SubmissionCloseDate():
         unawaited(_showSubmissionClosingWarningDialog(signal.date));
+      case ForgetProposalSuccessWorkspaceSignal():
+        _showForgetSuccessSnackBar();
     }
   }
 
@@ -113,6 +116,17 @@ class _WorkspacePageState extends State<WorkspacePage>
     ).show(context);
   }
 
+  void _showForgetSuccessSnackBar() {
+    VoicesSnackBar.hideCurrent(context);
+
+    VoicesSnackBar(
+      type: VoicesSnackBarType.success,
+      behavior: SnackBarBehavior.floating,
+      title: context.l10n.successProposalForgot,
+      message: context.l10n.successProposalForgotDescription,
+    ).show(context);
+  }
+
   Future<void> _showSubmissionClosingWarningDialog([
     DateTime? submissionCloseDate,
   ]) async {

catalyst_voices/apps/voices/lib/widgets/indicators/voices_loading_overlay.dart

@@ -114,6 +114,10 @@ class _VoicesLoadingOverlayState extends State<VoicesLoadingOverlay>
     );
 
     _showingSince = widget.show ? DateTimeExt.now() : null;
+
+    if (widget.show) {
+      _fadeInAnimController.value = _fadeInAnimController.upperBound;
+    }
   }
 
   void _hideNow() {

catalyst_voices/packages/internal/catalyst_voices_blocs/lib/src/workspace/workspace_bloc.dart

@@ -75,11 +75,15 @@ final class WorkspaceBloc extends Bloc<WorkspaceEvent, WorkspaceState>
     Emitter<WorkspaceState> emit,
   ) async {
     try {
+      emit(state.copyWith(isLoading: true));
       await _proposalService.deleteDraftProposal(event.ref);
+      emit(state.copyWith(userProposals: _removeProposal(event.ref)));
       emitSignal(const DeletedDraftWorkspaceSignal());
     } catch (error, stackTrace) {
       _logger.severe('Delete proposal failed', error, stackTrace);
       emitError(const LocalizedProposalDeletionException());
+    } finally {
+      emit(state.copyWith(isLoading: false));
     }
   }
 
@@ -138,12 +142,18 @@ final class WorkspaceBloc extends Bloc<WorkspaceEvent, WorkspaceState>
       return emitError(const LocalizedUnknownException());
     }
     try {
+      emit(state.copyWith(isLoading: true));
       await _proposalService.forgetProposal(
         proposalRef: proposal.selfRef as SignedDocumentRef,
         categoryId: proposal.categoryId,
       );
+      emit(state.copyWith(userProposals: _removeProposal(event.ref)));
+      emitSignal(const ForgetProposalSuccessWorkspaceSignal());
     } catch (e, stackTrace) {
+      emitError(LocalizedException.create(e));
       _logger.severe('Error forgetting proposal', e, stackTrace);
+    } finally {
+      emit(state.copyWith(isLoading: false));
     }
   }
 
@@ -164,12 +174,16 @@ final class WorkspaceBloc extends Bloc<WorkspaceEvent, WorkspaceState>
     Emitter<WorkspaceState> emit,
   ) async {
     try {
+      emit(state.copyWith(isLoading: true));
       final ref = await _proposalService.importProposal(event.proposalData);
       emitSignal(ImportedProposalWorkspaceSignal(proposalRef: ref));
     } catch (error, stackTrace) {
       _logger.severe('Importing proposal failed', error, stackTrace);
+      emit(state.copyWith(isLoading: false));
       emitError(LocalizedException.create(error));
     }
+    // We don't need to emit isLoading false here because it will be emitted
+    // in the stream subscription.
   }
 
   Future<void> _loadProposals(
@@ -185,6 +199,13 @@ final class WorkspaceBloc extends Bloc<WorkspaceEvent, WorkspaceState>
     );
   }
 
+  List<Proposal> _removeProposal(
+    DocumentRef proposalRef,
+  ) {
+    return [...state.userProposals]
+      ..removeWhere((e) => e.selfRef.id == proposalRef.id);
+  }
+
   void _setupProposalsSubscription() {
     _proposalsSubscription = _proposalService.watchUserProposals().listen(
       (proposals) {

catalyst_voices/packages/internal/catalyst_voices_blocs/lib/src/workspace/workspace_signal.dart

@@ -3,9 +3,10 @@ import 'package:equatable/equatable.dart';
 
 final class DeletedDraftWorkspaceSignal extends WorkspaceSignal {
   const DeletedDraftWorkspaceSignal();
+}
 
-  @override
-  List<Object?> get props => [];
+final class ForgetProposalSuccessWorkspaceSignal extends WorkspaceSignal {
+  const ForgetProposalSuccessWorkspaceSignal();
 }
 
 final class ImportedProposalWorkspaceSignal extends WorkspaceSignal {
@@ -37,4 +38,7 @@ final class SubmissionCloseDate extends WorkspaceSignal {
 
 sealed class WorkspaceSignal extends Equatable {
   const WorkspaceSignal();
+
+  @override
+  List<Object?> get props => [];
 }

catalyst_voices/packages/internal/catalyst_voices_blocs/lib/src/workspace/workspace_state.dart

@@ -40,7 +40,7 @@ final class WorkspaceState extends Equatable {
       .toList();
   bool get showError => error != null && !isLoading;
   bool get showLoading => isLoading;
-  bool get showProposals => error == null && !isLoading;
+  bool get showProposals => error == null;
   DateTime? get submissionCloseDate => timelineItems
       .firstWhereOrNull(
         (e) => e.stage == CampaignTimelineStage.proposalSubmission,

catalyst_voices/packages/internal/catalyst_voices_blocs/test/workspace/workspace_bloc_test.dart

@@ -0,0 +1,118 @@
+import 'dart:typed_data';
+
+import 'package:bloc_test/bloc_test.dart';
+import 'package:catalyst_voices_blocs/catalyst_voices_blocs.dart';
+import 'package:catalyst_voices_models/catalyst_voices_models.dart';
+import 'package:catalyst_voices_services/catalyst_voices_services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+void main() {
+  group(WorkspaceBloc, () {
+    late MockCampaignService mockCampaignService;
+    late MockProposalService mockProposalService;
+    late MockDocumentMapper mockDocumentMapper;
+    late MockDownloaderService mockDownloaderService;
+
+    late WorkspaceBloc workspaceBloc;
+
+    final proposalRef = SignedDocumentRef.generateFirstRef();
+    final documentData = DocumentData(
+      metadata: DocumentDataMetadata(
+        type: DocumentType.proposalDocument,
+        selfRef: proposalRef,
+        template: SignedDocumentRef.generateFirstRef(),
+        categoryId: SignedDocumentRef.generateFirstRef(),
+      ),
+      content: const DocumentDataContent({}),
+    );
+
+    setUpAll(() {
+      registerFallbackValue(SignedDocumentRef.generateFirstRef());
+      registerFallbackValue(documentData);
+      registerFallbackValue(Uint8List(0));
+    });
+
+    setUp(() async {
+      mockCampaignService = MockCampaignService();
+      mockProposalService = MockProposalService();
+      mockDocumentMapper = MockDocumentMapper();
+      mockDownloaderService = MockDownloaderService();
+
+      workspaceBloc = WorkspaceBloc(
+        mockCampaignService,
+        mockProposalService,
+        mockDocumentMapper,
+        mockDownloaderService,
+      );
+    });
+
+    tearDown(() async {
+      await workspaceBloc.close();
+    });
+    test('initial state is correct', () {
+      expect(workspaceBloc.state, const WorkspaceState());
+    });
+
+    blocTest<WorkspaceBloc, WorkspaceState>(
+      'emit loading state and loaded state when watching proposals succeeds',
+      build: () {
+        when(() => mockProposalService.watchUserProposals()).thenAnswer(
+          (_) => Stream.value(
+            [ProposalWithVersionX.dummy(ProposalPublish.localDraft)],
+          ),
+        );
+        return workspaceBloc;
+      },
+      act: (bloc) => bloc.add(const WatchUserProposalsEvent()),
+      expect: () => [
+        isA<WorkspaceState>().having((s) => s.isLoading, 'isLoading', true),
+        isA<WorkspaceState>().having((s) => s.isLoading, 'isLoading', false),
+      ],
+    );
+
+    blocTest<WorkspaceBloc, WorkspaceState>(
+      'watch user proposals - success',
+      build: () {
+        when(() => mockProposalService.watchUserProposals()).thenAnswer(
+          (_) => Stream.value([
+            ProposalWithVersionX.dummy(ProposalPublish.localDraft),
+            ProposalWithVersionX.dummy(ProposalPublish.localDraft),
+          ]),
+        );
+        return workspaceBloc;
+      },
+      act: (bloc) => bloc.add(const WatchUserProposalsEvent()),
+      expect: () => [
+        isA<WorkspaceState>().having((s) => s.isLoading, 'isLoading', true),
+        isA<WorkspaceState>()
+            .having((s) => s.isLoading, 'isLoading', false)
+            .having((s) => s.userProposals.length, 'proposals count', 2),
+      ],
+    );
+
+    blocTest<WorkspaceBloc, WorkspaceState>(
+      'watch user proposals - failure',
+      build: () {
+        when(() => mockProposalService.watchUserProposals())
+            .thenAnswer((_) => Stream.error(Exception('Failed to load')));
+        return workspaceBloc;
+      },
+      act: (bloc) => bloc.add(const WatchUserProposalsEvent()),
+      expect: () => [
+        isA<WorkspaceState>().having((s) => s.isLoading, 'isLoading', true),
+        isA<WorkspaceState>()
+            .having((s) => s.isLoading, 'isLoading', false)
+            .having((s) => s.error, 'has error', isNotNull),
+      ],
+    );
+  });
+}
+
+class MockCampaignService extends Mock implements CampaignService {}
+
+class MockDocumentMapper extends Mock implements DocumentMapper {}
+
+class MockDownloaderService extends Mock implements DownloaderService {}
+
+class MockProposalService extends Mock implements ProposalService {}

catalyst_voices/packages/internal/catalyst_voices_localization/lib/l10n/intl_en.arb

@@ -2124,6 +2124,14 @@
   "@successProposalDeletedDescription": {
     "description": "Description of success message when draft is deleted"
   },
+  "successProposalForgot": "Proposal forgotten",
+  "@successProposalForgot": {
+    "description": "Success message when public draft/final proposal is forgotten"
+  },
+  "successProposalForgotDescription": "Your local proposal has been forgotten. No one can see it anymore.",
+  "@successProposalForgotDescription": {
+    "description": "Description of success message when public draft/final proposal is forgotten"
+  },
   "errorProposalDeleted": "Error deleting proposal",
   "@errorProposalDeleted": {
     "description": "Error message when draft is not deleted"