Merge branch 'blocking' into 'main'

Blocking

See merge request mysocialportal/relatica!39

lib/controls/standard_app_drawer.dart

@@ -74,6 +74,11 @@ class StandardAppDrawer extends StatelessWidget {
               () => context.pushNamed(ScreenPaths.messages),
             ),
             const Divider(),
+            buildMenuButton(
+              context,
+              'Blocks',
+              () => context.pushNamed(ScreenPaths.blocks),
+            ),
             buildMenuButton(
               context,
               'Groups Management',

lib/di_initialization.dart

@@ -16,6 +16,7 @@ import 'globals.dart';
 import 'models/auth/profile.dart';
 import 'models/instance_info.dart';
 import 'services/auth_service.dart';
+import 'services/blocks_manager.dart';
 import 'services/connections_manager.dart';
 import 'services/direct_message_service.dart';
 import 'services/entry_manager_service.dart';
@@ -120,7 +121,9 @@ Future<void> dependencyInjectionInitialization() async {
   getIt.registerSingleton<ActiveProfileSelector<InteractionsManager>>(
       ActiveProfileSelector((p) => InteractionsManager(p))
         ..subscribeToProfileSwaps());
-
+  getIt.registerSingleton<ActiveProfileSelector<BlocksManager>>(
+      ActiveProfileSelector((p) => BlocksManager(p))
+        ..subscribeToProfileSwaps());
   setupUpdateTimers();
 }
 

lib/friendica_client/friendica_client.dart

@@ -471,6 +471,33 @@ class RelationshipsClient extends FriendicaClient {
 
   RelationshipsClient(super.credentials) : super();
 
+  FutureResult<PagedResponse<List<Connection>>, ExecError> getBlocks(
+      PagingData page) async {
+    _networkStatusService.startNotificationUpdate();
+    final url = 'https://$serverName/api/v1/blocks';
+    final request = Uri.parse('$url&${page.toQueryParameters()}');
+    _logger.finest(() => 'Getting blocks for $page');
+    final result =
+        await _getApiListRequest(request).transformAsync((response) async {
+      final blocks = <Connection>[];
+
+      final st = Stopwatch()..start();
+      for (final json in response.data) {
+        if (st.elapsedMilliseconds > _maxProcessingMillis) {
+          await Future.delayed(_processingSleep, () => st.reset());
+        }
+        blocks.add(
+          ConnectionMastodonExtensions.fromJson(json)
+              .copy(status: ConnectionStatus.blocked),
+        );
+      }
+      return PagedResponse(blocks,
+          id: response.id, previous: response.previous, next: response.next);
+    });
+    _networkStatusService.finishNotificationUpdate();
+    return result.execErrorCast();
+  }
+
   FutureResult<PagedResponse<List<Connection>>, ExecError> getMyFollowing(
       PagingData page) async {
     _logger.fine(() => 'Getting following with paging data $page');
@@ -617,30 +644,47 @@ class RelationshipsClient extends FriendicaClient {
         : ExecError(type: ErrorType.localError, message: error.toString()));
   }
 
+  FutureResult<Connection, ExecError> blockConnection(
+      Connection connection) async {
+    final id = connection.id;
+    final url = Uri.parse('https://$serverName/api/v1/accounts/$id/block');
+    final result = await postUrl(url, {}, headers: _headers).transform(
+      (_) => connection.copy(status: ConnectionStatus.blocked),
+    );
+    return result.execErrorCast();
+  }
+
+  FutureResult<Connection, ExecError> unblockConnection(
+      Connection connection) async {
+    final id = connection.id;
+    final url = Uri.parse('https://$serverName/api/v1/accounts/$id/unblock');
+    final result = await postUrl(url, {}, headers: _headers)
+        .transformAsync((jsonString) async {
+      return _updateConnectionFromFollowRequestResult(connection, jsonString);
+    });
+    return result.execErrorCast();
+  }
+
   FutureResult<Connection, ExecError> followConnection(
       Connection connection) async {
     final id = connection.id;
     final url = Uri.parse('https://$serverName/api/v1/accounts/$id/follow');
-    final result = await postUrl(url, {}, headers: _headers)
+    final result =
-        .andThenSuccessAsync((jsonString) async {
+        await postUrl(url, {}, headers: _headers).transform((jsonString) {
       return _updateConnectionFromFollowRequestResult(connection, jsonString);
     });
-    return result.mapError((error) => error is ExecError
+    return result.execErrorCast();
-        ? error
-        : ExecError(type: ErrorType.localError, message: error.toString()));
   }
 
   FutureResult<Connection, ExecError> unFollowConnection(
       Connection connection) async {
     final id = connection.id;
     final url = Uri.parse('https://$serverName/api/v1/accounts/$id/unfollow');
-    final result = await postUrl(url, {}, headers: _headers)
+    final result =
-        .andThenSuccessAsync((jsonString) async {
+        await postUrl(url, {}, headers: _headers).transform((jsonString) {
       return _updateConnectionFromFollowRequestResult(connection, jsonString);
     });
-    return result.mapError((error) => error is ExecError
+    return result.execErrorCast();
-        ? error
-        : ExecError(type: ErrorType.localError, message: error.toString()));
   }
 
   Connection _updateConnectionFromFollowRequestResult(

lib/main.dart

@@ -11,6 +11,7 @@ import 'di_initialization.dart';
 import 'globals.dart';
 import 'routes.dart';
 import 'services/auth_service.dart';
+import 'services/blocks_manager.dart';
 import 'services/connections_manager.dart';
 import 'services/direct_message_service.dart';
 import 'services/entry_manager_service.dart';
@@ -27,7 +28,9 @@ import 'utils/old_android_letsencrypte_cert.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
-  MediaKit.ensureInitialized();
+  if (kReleaseMode) {
+    MediaKit.ensureInitialized();
+  }
   // await dotenv.load(fileName: '.env');
   const enablePreview = false;
   Logger.root.level = Level.FINER;
@@ -108,7 +111,10 @@ class App extends StatelessWidget {
                   ActiveProfileSelector<InteractionsManager>>(
                 create: (_) =>
                     getIt<ActiveProfileSelector<InteractionsManager>>(),
-              )
+              ),
+              ChangeNotifierProvider<ActiveProfileSelector<BlocksManager>>(
+                create: (_) => getIt<ActiveProfileSelector<BlocksManager>>(),
+              ),
             ],
             child: MaterialApp.router(
               useInheritedMediaQuery: true,

lib/models/connection.dart

@@ -113,6 +113,7 @@ class Connection {
 }
 
 enum ConnectionStatus {
+  blocked(0),
   youFollowThem(1),
   theyFollowYou(2),
   mutual(3),
@@ -145,6 +146,8 @@ extension FriendStatusWriter on ConnectionStatus {
         return "You";
       case ConnectionStatus.unknown:
         return 'Unknown';
+      case ConnectionStatus.blocked:
+        return 'Blocked';
     }
   }
 }

lib/routes.dart

@@ -2,6 +2,7 @@ import 'package:go_router/go_router.dart';
 
 import 'globals.dart';
 import 'models/interaction_type_enum.dart';
+import 'screens/blocks_screen.dart';
 import 'screens/contacts_screen.dart';
 import 'screens/editor.dart';
 import 'screens/follow_request_adjudication_screen.dart';
@@ -28,6 +29,7 @@ import 'screens/user_profile_screen.dart';
 import 'services/auth_service.dart';
 
 class ScreenPaths {
+  static String blocks = '/blocks';
   static String thread = '/thread';
   static String connectHandle = '/connect';
   static String contacts = '/contacts';
@@ -73,6 +75,11 @@ final appRouter = GoRouter(
       return null;
     },
     routes: [
+      GoRoute(
+        path: ScreenPaths.blocks,
+        name: ScreenPaths.blocks,
+        builder: (context, state) => const BlocksScreen(),
+      ),
       GoRoute(
         path: ScreenPaths.signin,
         name: ScreenPaths.signin,

lib/screens/blocks_screen.dart

@@ -0,0 +1,50 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:provider/provider.dart';
+
+import '../routes.dart';
+import '../services/blocks_manager.dart';
+import '../utils/active_profile_selector.dart';
+
+class BlocksScreen extends StatelessWidget {
+  const BlocksScreen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final manager =
+        context.watch<ActiveProfileSelector<BlocksManager>>().activeEntry.value;
+    final blocks = manager.getBlocks();
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Blocks'),
+      ),
+      body: SafeArea(
+        child: ListView.builder(
+          itemBuilder: (context, index) {
+            final contact = blocks[index];
+            return ListTile(
+              onTap: () async {
+                context.pushNamed(ScreenPaths.userProfile,
+                    params: {'id': contact.id});
+              },
+              title: Text(
+                '${contact.name} (${contact.handle})',
+                softWrap: true,
+              ),
+              subtitle: Text(
+                'Last Status: ${contact.lastStatus?.toIso8601String() ?? "Unknown"}',
+                softWrap: true,
+              ),
+              trailing: ElevatedButton(
+                onPressed: () async => await manager.unblockConnection(contact),
+                child: const Text('Unblock'),
+              ),
+            );
+          },
+          itemCount: blocks.length,
+        ),
+      ),
+    );
+  }
+}

lib/screens/follow_request_adjudication_screen.dart

@@ -13,6 +13,7 @@ import '../routes.dart';
 import '../services/connections_manager.dart';
 import '../services/feature_version_checker.dart';
 import '../services/follow_requests_manager.dart';
+import '../services/network_status_service.dart';
 import '../services/notifications_manager.dart';
 import '../utils/active_profile_selector.dart';
 import '../utils/url_opening_utils.dart';
@@ -33,6 +34,7 @@ class _FollowRequestAdjudicationScreenState
 
   @override
   Widget build(BuildContext context) {
+    final nss = getIt<NetworkStatusService>();
     final fm =
         getIt<ActiveProfileSelector<FollowRequestsManager>>().activeEntry.value;
     final cm = context
@@ -71,7 +73,15 @@ class _FollowRequestAdjudicationScreenState
           break;
         case ConnectionStatus.you:
         case ConnectionStatus.unknown:
-          body = Text('Invalid state, nothing to do here: ${contact.status}');
+          body = Text(nss.connectionUpdateStatus.value
+              ? 'Loading...'
+              : 'Invalid state, nothing to do here: ${contact.status}');
+          break;
+        case ConnectionStatus.blocked:
+          // we should never get here because a blocked user shouldn't be allowed to create a connection request.
+          body = const Text(
+            'Use is blocked. Unblock to accept connection request.',
+          );
           break;
       }
     }

lib/screens/user_profile_screen.dart

@@ -10,6 +10,7 @@ import '../models/connection.dart';
 import '../models/group_data.dart';
 import '../routes.dart';
 import '../services/auth_service.dart';
+import '../services/blocks_manager.dart';
 import '../services/connections_manager.dart';
 import '../utils/active_profile_selector.dart';
 import '../utils/snackbar_builder.dart';
@@ -37,17 +38,22 @@ class _UserProfileScreenState extends State<UserProfileScreen> {
 
   @override
   Widget build(BuildContext context) {
-    final manager = context
+    final connectionManager = context
         .watch<ActiveProfileSelector<ConnectionsManager>>()
         .activeEntry
         .value;
-    final body = manager.getById(widget.userId).fold(onSuccess: (profile) {
+    final blocksManager =
+        context.watch<ActiveProfileSelector<BlocksManager>>().activeEntry.value;
+    final body =
+        connectionManager.getById(widget.userId).fold(onSuccess: (profile) {
       final notMyProfile =
           getIt<AccountsService>().currentProfile.userId != profile.id;
 
       return RefreshIndicator(
         onRefresh: () async {
-          await manager.fullRefresh(profile);
+          await connectionManager.fullRefresh(profile,
+              withNotifications: false);
+          await blocksManager.updateBlock(profile);
         },
         child: SingleChildScrollView(
           physics: const AlwaysScrollableScrollPhysics(),
@@ -73,11 +79,15 @@ class _UserProfileScreenState extends State<UserProfileScreen> {
               const VerticalPadding(),
               Text('( ${profile.status.label()} )'),
               const VerticalPadding(),
-              Row(
+              Wrap(
-                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                spacing: 10.0,
+                runSpacing: 10.0,
                 children: [
-                  if (notMyProfile)
+                  if (notMyProfile) ...[
-                    buildConnectionStatusToggle(context, profile, manager),
+                    buildConnectionStatusToggle(
+                        context, profile, connectionManager),
+                    buildBlockToggle(context, profile, blocksManager),
+                  ],
                   ElevatedButton(
                       onPressed: () => context.pushNamed(
                             ScreenPaths.userPosts,
@@ -107,7 +117,7 @@ class _UserProfileScreenState extends State<UserProfileScreen> {
               const VerticalPadding(),
               if (profile.status == ConnectionStatus.mutual ||
                   profile.status == ConnectionStatus.youFollowThem)
-                buildGroups(context, profile, manager),
+                buildGroups(context, profile, connectionManager),
             ],
           ),
         ),
@@ -183,6 +193,66 @@ class _UserProfileScreenState extends State<UserProfileScreen> {
     );
   }
 
+  Widget buildBlockToggle(
+    BuildContext context,
+    Connection profile,
+    BlocksManager manager,
+  ) {
+    late Widget blockToggleButton;
+    switch (profile.status) {
+      case ConnectionStatus.blocked:
+        blockToggleButton = ElevatedButton(
+          onPressed: isUpdating
+              ? null
+              : () async {
+                  final confirm =
+                      await showYesNoDialog(context, 'Unblock ${profile.name}');
+                  if (confirm != true) {
+                    return;
+                  }
+                  setState(() {
+                    isUpdating = true;
+                  });
+                  await manager.unblockConnection(profile);
+                  setState(() {
+                    isUpdating = false;
+                  });
+                },
+          child: const Text('Unblock'),
+        );
+        break;
+      case ConnectionStatus.mutual:
+      case ConnectionStatus.theyFollowYou:
+      case ConnectionStatus.youFollowThem:
+      case ConnectionStatus.none:
+      case ConnectionStatus.unknown:
+        blockToggleButton = ElevatedButton(
+          onPressed: isUpdating
+              ? null
+              : () async {
+                  final confirm =
+                      await showYesNoDialog(context, 'Block ${profile.name}');
+                  if (confirm != true) {
+                    return;
+                  }
+                  setState(() {
+                    isUpdating = true;
+                  });
+                  await manager.blockConnection(profile);
+                  setState(() {
+                    isUpdating = false;
+                  });
+                },
+          child: const Text('Block'),
+        );
+        break;
+      case ConnectionStatus.you:
+        blockToggleButton = const SizedBox();
+        break;
+    }
+    return blockToggleButton;
+  }
+
   Widget buildConnectionStatusToggle(
     BuildContext context,
     Connection profile,
@@ -234,6 +304,7 @@ class _UserProfileScreenState extends State<UserProfileScreen> {
           child: const Text('Follow'),
         );
         break;
+      case ConnectionStatus.blocked:
       case ConnectionStatus.you:
       case ConnectionStatus.unknown:
         followToggleButton = const SizedBox();

lib/services/blocks_manager.dart

@@ -0,0 +1,163 @@
+import 'dart:collection';
+
+import 'package:flutter/foundation.dart';
+import 'package:logging/logging.dart';
+import 'package:result_monad/result_monad.dart';
+
+import '../friendica_client/friendica_client.dart';
+import '../friendica_client/paged_response.dart';
+import '../friendica_client/paging_data.dart';
+import '../globals.dart';
+import '../models/auth/profile.dart';
+import '../models/connection.dart';
+import '../utils/active_profile_selector.dart';
+import 'connections_manager.dart';
+
+class BlocksManager extends ChangeNotifier {
+  static final _logger = Logger('$BlocksManager');
+  final Profile profile;
+  final _blocks = <Connection>[];
+  final _pages = <PagedResponse>[];
+
+  var mayHaveMore = true;
+  var initialized = false;
+
+  BlocksManager(this.profile);
+
+  void clear() {
+    _blocks.clear();
+    _pages.clear();
+    mayHaveMore = true;
+  }
+
+  List<Connection> getBlocks() {
+    if (!initialized) {
+      updateBlocks(nextOnly: false);
+    }
+
+    return UnmodifiableListView(_blocks);
+  }
+
+  Future<void> blockConnection(Connection connection) async {
+    _logger
+        .finest('Attempting to block ${connection.name}: ${connection.status}');
+    await RelationshipsClient(profile)
+        .blockConnection(connection)
+        .withResult((blockedUser) {
+      getIt<ActiveProfileSelector<ConnectionsManager>>()
+          .getForProfile(profile)
+          .withResult(
+            (cm) => cm.upsertConnection(blockedUser),
+          );
+    }).match(
+      onSuccess: (blockedUser) {
+        _logger.finest(
+            'Successfully blocked ${blockedUser.name}: ${blockedUser.status}');
+        final existingIndex = _blocks.indexOf(connection);
+        if (existingIndex < 0) {
+          _blocks.add(blockedUser);
+          _sortBlocks();
+        } else {
+          _blocks.removeAt(existingIndex);
+          _blocks.insert(existingIndex, blockedUser);
+        }
+
+        notifyListeners();
+      },
+      onError: (error) {
+        _logger.severe('Error blocking ${connection.name}: $error');
+      },
+    );
+  }
+
+  Future<void> unblockConnection(Connection connection) async {
+    _logger.finest(
+        'Attempting to unblock ${connection.name}: ${connection.status}');
+    await RelationshipsClient(profile)
+        .unblockConnection(connection)
+        .withResult((blockedUser) {
+      getIt<ActiveProfileSelector<ConnectionsManager>>()
+          .getForProfile(profile)
+          .withResult(
+            (cm) => cm.upsertConnection(blockedUser),
+          );
+    }).match(
+      onSuccess: (unblockedUser) {
+        _logger.finest(
+            'Successfully unblocked ${unblockedUser.name}: ${unblockedUser.status}');
+        final existingIndex = _blocks.indexOf(connection);
+        if (existingIndex >= 0) {
+          _blocks.removeAt(existingIndex);
+          _sortBlocks();
+        }
+        notifyListeners();
+      },
+      onError: (error) {
+        _logger.severe('Error unblocking ${connection.name}: $error');
+      },
+    );
+  }
+
+  Future<void> updateBlock(Connection connection) async {
+    final id = int.parse(connection.id);
+    final page = PagingData(minId: id - 1, maxId: id + 1);
+    await RelationshipsClient(profile).getBlocks(page).withResult((blocks) {
+      final conBlock = blocks.data.where((b) => b.id == connection.id).toList();
+      if (conBlock.isEmpty) {
+        _blocks.remove(connection);
+      } else {
+        _blocks.add(conBlock.first);
+        getIt<ActiveProfileSelector<ConnectionsManager>>()
+            .getForProfile(profile)
+            .withResult((cm) => cm.upsertConnection(conBlock.first));
+      }
+
+      notifyListeners();
+    });
+  }
+
+  Future<void> updateBlocks({required bool nextOnly}) async {
+    if (nextOnly) {
+      clear();
+    }
+    final client = RelationshipsClient(profile);
+    final bootstrapping = _pages.isEmpty;
+
+    var page = bootstrapping ? PagingData() : _pages.last.next;
+
+    while (page != null) {
+      page = await client
+          .getBlocks(page)
+          .withResult((result) {
+            _blocks.addAll(result.data);
+            _pages.add(result);
+          })
+          .withError(
+            (error) => _logger.severe('Error getting blocks data: $error'),
+          )
+          .fold<PagingData?>(
+            onSuccess: (result) => result.next,
+            onError: (error) => null,
+          );
+
+      if (nextOnly) {
+        break;
+      }
+    }
+
+    getIt<ActiveProfileSelector<ConnectionsManager>>()
+        .getForProfile(profile)
+        .withResult((cm) => cm.upsertAllConnections(_blocks));
+
+    _sortBlocks();
+    notifyListeners();
+  }
+
+  void _sortBlocks() {
+    _blocks.sort(
+      (b1, b2) => b1.name.toLowerCase().compareTo(
+            b2.name.toLowerCase(),
+          ),
+    );
+  }
+}

lib/services/connections_manager.dart

@@ -357,8 +357,8 @@ class ConnectionsManager extends ChangeNotifier {
   }
 
   Result<Connection, ExecError> getById(String id, {bool forceUpdate = false}) {
-    return conRepo.getById(id).andThenSuccess((c) {
+    return conRepo.getById(id).transform((c) {
-      if (forceUpdate) {
+      if (c.status == ConnectionStatus.unknown && forceUpdate) {
         _refreshConnection(c, true);
       }
       return c;
@@ -383,11 +383,16 @@ class ConnectionsManager extends ChangeNotifier {
     }).execErrorCast();
   }
 
-  Future<void> fullRefresh(Connection connection) async {
+  Future<void> fullRefresh(
+    Connection connection, {
+    bool withNotifications = true,
+  }) async {
     await _updateMyGroups(false);
     await _refreshGroupListData(connection.id, false);
     await _refreshConnection(connection, false);
-    notifyListeners();
+    if (withNotifications) {
+      notifyListeners();
+    }
   }
 
   Future<void> _refreshGroupListData(String id, bool withNotification) async {

lib/update_timer_initialization.dart

@@ -33,7 +33,7 @@ Future<void> executeUpdatesForProfile(Profile profile) async {
       .getForProfile(profile)
       .withResultAsync((info) async {
     final dt = DateTime.now().difference(info.lastMyConnectionsUpdate);
-    _logger.info('Time since last connections update: $dt');
+    _logger.finer('Time since last connections update: $dt');
     if (dt >= _connectionsRefreshInterval) {
       await getIt<ActiveProfileSelector<ConnectionsManager>>()
           .getForProfile(profile)