store: Add ensureFreshRealmMetadata

A helper which ensures realm metadata (name and icon) are up-to-date
for each account.

Author: rajveermalviya

lib/model/store.dart

@@ -345,6 +345,64 @@ abstract class GlobalStore extends ChangeNotifier {
     ));
   }
 
+  /// Ensure the realm metadata of each account is up-to-date.
+  ///
+  /// Fetches server settings for each account and then calls [updateRealmData]
+  /// to update the realm metadata (name and icon).
+  ///
+  /// The updation for some accounts may be skipped if:
+  ///  - The per account store for the account is already loaded or is loading.
+  ///  - The version of corresponding realm server is unsupported.
+  ///
+  /// Returns immediately; the fetches and updates are done asynchronously.
+  void ensureFreshRealmMetadata() {
+    for (final accountId in accountIds) {
+      // Avoid updating realm metadata if per account store has already
+      // loaded or is being loaded. It should be updated with data from
+      // the initial snapshot or realm update events.
+      if (_perAccountStoresLoading.containsKey(accountId)) continue;
+      if (_perAccountStores.containsKey(accountId)) continue;
+
+      final account = getAccount(accountId);
+      if (account == null) continue;
+
+      // Fetch the server settings and update the realm data without awaiting.
+      // This allows fetching server settings of all the accounts parallelly.
+      unawaited(() async {
+        final GetServerSettingsResult serverSettings;
+        final connection = apiConnection(
+          realmUrl: account.realmUrl,
+          zulipFeatureLevel: null);
+        try {
+          serverSettings = await getServerSettings(connection);
+          final zulipVersionData = ZulipVersionData.fromServerSettings(serverSettings);
+          if (zulipVersionData.isUnsupported) {
+            throw ServerVersionUnsupportedException(zulipVersionData);
+          }
+        } on MalformedServerResponseException catch (e) {
+          final zulipVersionData = ZulipVersionData.fromMalformedServerResponseException(e);
+          if (zulipVersionData != null && zulipVersionData.isUnsupported) {
+            throw ServerVersionUnsupportedException(zulipVersionData);
+          }
+          rethrow;
+        } finally {
+          connection.close();
+        }
+
+        // Account got logged out while fetching server settings.
+        if (getAccount(accountId) == null) return;
+
+        if (_perAccountStoresLoading.containsKey(accountId)) return;
+        if (_perAccountStores.containsKey(accountId)) return;
+
+        await updateRealmData(
+          accountId,
+          realmName: serverSettings.realmName,
+          realmIcon: serverSettings.realmIcon);
+      }());
+    }
+  }
+
   /// Update an account in the underlying data store.
   Future<void> doUpdateAccount(int accountId, AccountsCompanion data);
 

test/model/store_test.dart

@@ -391,6 +391,90 @@ void main() {
         realmIcon: Value(Uri.parse('/image-b.png'))));
   });
 
+  group('GlobalStore.ensureFreshRealmMetadata', () {
+    test('smoke; populates/updates realm data', () => awaitFakeAsync((async) async {
+      final account1 = eg.selfAccount.copyWith(
+        realmUrl: Uri.parse('https://realm1.example.com'),
+        realmName: const Value.absent(), // account without realm metadata
+        realmIcon: const Value.absent());
+      final account2 = eg.otherAccount.copyWith(
+        realmUrl: Uri.parse('https://realm2.example.com'),
+        realmName: Value('Old realm 2 name'), // account with old realm metadata
+        realmIcon: Value(Uri.parse('/old-realm-2-image.png')));
+
+      final globalStore = eg.globalStore(accounts: [account1, account2]);
+      globalStore.useCachedApiConnections = true;
+
+      final connection1 = globalStore.apiConnection(
+        realmUrl: account1.realmUrl, zulipFeatureLevel: null);
+      final serverSettings1 = eg.serverSettings(
+        realmUrl: account1.realmUrl,
+        realmName: 'Realm 1 name',
+        realmIcon: Uri.parse('/realm-1-image.png'));
+      connection1.prepare(json: serverSettings1.toJson());
+
+      final connection2 = globalStore.apiConnection(
+        realmUrl: account2.realmUrl, zulipFeatureLevel: null);
+      final serverSettings2 = eg.serverSettings(
+        realmUrl: account2.realmUrl,
+        realmName: 'New realm 2 name',
+        realmIcon: Uri.parse('/new-realm-2-image.png'));
+      connection2.prepare(json: serverSettings2.toJson());
+
+      globalStore.ensureFreshRealmMetadata();
+      async.elapse(Duration.zero);
+
+      check(globalStore.getAccount(account1.id)).isNotNull()
+        ..realmName.equals('Realm 1 name')
+        ..realmIcon.equals(Uri.parse('/realm-1-image.png'));
+      check(globalStore.getAccount(account2.id)).isNotNull()
+        ..realmName.equals('New realm 2 name')
+        ..realmIcon.equals(Uri.parse('/new-realm-2-image.png'));
+    }));
+
+    test('ignores per account store loaded account', () => awaitFakeAsync((async) async {
+      final account1 = eg.selfAccount.copyWith(
+        realmUrl: Uri.parse('https://realm1.example.com'),
+        realmName: Value('Old realm 1 name'),
+        realmIcon: Value(Uri.parse('/old-realm-1-image.png')));
+      final account2 = eg.otherAccount.copyWith(
+        realmUrl: Uri.parse('https://realm2.example.com'),
+        realmName: Value('Old realm 2 name'),
+        realmIcon: Value(Uri.parse('/old-realm-2-image.png')));
+
+      final globalStore = eg.globalStore();
+      await globalStore.add(account1, eg.initialSnapshot(
+        realmName: account1.realmName,
+        realmIconUrl: account1.realmIcon,
+        realmUsers: [eg.selfUser]));
+      await globalStore.add(account2, eg.initialSnapshot(
+        realmName: account2.realmName,
+        realmIconUrl: account2.realmIcon,
+        realmUsers: [eg.otherUser]));
+      globalStore.useCachedApiConnections = true;
+
+      final connection1 = globalStore.apiConnection(
+        realmUrl: account1.realmUrl, zulipFeatureLevel: null);
+      final serverSettings1 = eg.serverSettings(
+        realmUrl: account1.realmUrl,
+        realmName: 'New realm 1 name',
+        realmIcon: Uri.parse('/new-realm-1-image.png'));
+      connection1.prepare(json: serverSettings1.toJson());
+
+      await globalStore.perAccount(account2.id);
+
+      globalStore.ensureFreshRealmMetadata();
+      async.elapse(Duration.zero);
+
+      check(globalStore.getAccount(account1.id)).isNotNull()
+        ..realmName.equals('New realm 1 name')
+        ..realmIcon.equals(Uri.parse('/new-realm-1-image.png'));
+      check(globalStore.getAccount(account2.id)).isNotNull()
+        ..realmName.equals('Old realm 2 name')
+        ..realmIcon.equals(Uri.parse('/old-realm-2-image.png'));
+    }));
+  });
+
   group('GlobalStore.removeAccount', () {
     void checkGlobalStore(GlobalStore store, int accountId, {
       required bool expectAccount,