2023-01-16 21:31:17 +00:00
|
|
|
import 'dart:collection';
|
2022-12-15 03:27:30 +00:00
|
|
|
import 'dart:math';
|
|
|
|
|
2022-12-08 18:37:30 +00:00
|
|
|
import 'package:flutter/material.dart';
|
|
|
|
import 'package:logging/logging.dart';
|
2022-11-18 21:50:15 +00:00
|
|
|
import 'package:result_monad/result_monad.dart';
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
import '../data/interfaces/circles_repo_intf.dart';
|
2023-01-16 21:31:17 +00:00
|
|
|
import '../data/interfaces/connections_repo_intf.dart';
|
2023-02-24 21:36:20 +00:00
|
|
|
import '../friendica_client/friendica_client.dart';
|
2023-01-24 03:37:09 +00:00
|
|
|
import '../friendica_client/paging_data.dart';
|
2022-12-08 18:37:30 +00:00
|
|
|
import '../globals.dart';
|
2023-04-28 18:23:01 +00:00
|
|
|
import '../models/auth/profile.dart';
|
2023-11-15 21:05:45 +00:00
|
|
|
import '../models/circle_data.dart';
|
2022-11-18 21:50:15 +00:00
|
|
|
import '../models/connection.dart';
|
2022-12-08 18:37:30 +00:00
|
|
|
import '../models/exec_error.dart';
|
2023-04-28 18:23:01 +00:00
|
|
|
import '../utils/active_profile_selector.dart';
|
|
|
|
import 'persistent_info_service.dart';
|
2023-04-28 02:05:10 +00:00
|
|
|
|
2022-12-08 18:37:30 +00:00
|
|
|
class ConnectionsManager extends ChangeNotifier {
|
|
|
|
static final _logger = Logger('$ConnectionsManager');
|
2023-01-18 04:03:50 +00:00
|
|
|
late final IConnectionsRepo conRepo;
|
2023-11-15 21:05:45 +00:00
|
|
|
late final ICirclesRepo circlesRepo;
|
2023-04-28 18:23:01 +00:00
|
|
|
late final Profile profile;
|
2023-11-15 21:05:45 +00:00
|
|
|
var circlesNotInitialized = true;
|
2023-04-28 18:23:01 +00:00
|
|
|
var _lastUpdateStatus = '';
|
2023-04-28 02:05:10 +00:00
|
|
|
|
2023-04-28 18:23:01 +00:00
|
|
|
String get lastUpdateStatus => _lastUpdateStatus.isNotEmpty
|
|
|
|
? _lastUpdateStatus
|
|
|
|
: getIt<ActiveProfileSelector<PersistentInfoService>>()
|
|
|
|
.getForProfile(profile)
|
|
|
|
.transform(
|
|
|
|
(info) => 'Last updated at: ${info.lastMyConnectionsUpdate}')
|
|
|
|
.withResult((text) => _lastUpdateStatus = text)
|
|
|
|
.getValueOrElse(() => 'Unknown');
|
2023-01-16 21:31:17 +00:00
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
ConnectionsManager(this.profile, this.conRepo, this.circlesRepo);
|
2022-11-18 21:50:15 +00:00
|
|
|
|
2023-04-28 01:48:01 +00:00
|
|
|
void clear() {
|
|
|
|
conRepo.clear();
|
2023-11-15 21:05:45 +00:00
|
|
|
circlesRepo.clear();
|
|
|
|
circlesNotInitialized = true;
|
2023-04-28 18:23:01 +00:00
|
|
|
_lastUpdateStatus = '';
|
2023-04-28 01:48:01 +00:00
|
|
|
notifyListeners();
|
|
|
|
}
|
|
|
|
|
2022-12-28 21:13:17 +00:00
|
|
|
List<Connection> getKnownUsersByName(String name) {
|
2023-01-18 04:03:50 +00:00
|
|
|
return conRepo.getKnownUsersByName(name);
|
2022-12-28 21:13:17 +00:00
|
|
|
}
|
|
|
|
|
2023-04-19 00:33:09 +00:00
|
|
|
bool upsertConnection(Connection connection) {
|
|
|
|
if (connection.status != ConnectionStatus.unknown) {
|
|
|
|
return conRepo.upsertConnection(connection);
|
|
|
|
}
|
|
|
|
|
|
|
|
return conRepo.getById(connection.id).fold(
|
|
|
|
onSuccess: (original) => conRepo.upsertConnection(
|
|
|
|
connection.copy(status: original.status),
|
|
|
|
),
|
|
|
|
onError: (_) => conRepo.upsertConnection(connection),
|
|
|
|
);
|
2022-11-18 21:50:15 +00:00
|
|
|
}
|
|
|
|
|
2023-04-28 12:41:51 +00:00
|
|
|
Future<bool> upsertAllConnections(Iterable<Connection> newConnections) async {
|
|
|
|
var result = true;
|
|
|
|
for (var c in newConnections) {
|
|
|
|
result &= await Future.delayed(Duration.zero, () => upsertConnection(c));
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2022-11-18 21:50:15 +00:00
|
|
|
}
|
|
|
|
|
2022-12-19 18:59:33 +00:00
|
|
|
Future<void> acceptFollowRequest(Connection connection) async {
|
|
|
|
_logger.finest(
|
|
|
|
'Attempting to accept follow request ${connection.name}: ${connection.status}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile).acceptFollow(connection).match(
|
2022-12-19 18:59:33 +00:00
|
|
|
onSuccess: (update) {
|
|
|
|
_logger
|
|
|
|
.finest('Successfully followed ${update.name}: ${update.status}');
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-19 18:59:33 +00:00
|
|
|
notifyListeners();
|
|
|
|
},
|
|
|
|
onError: (error) {
|
2023-01-31 21:40:47 +00:00
|
|
|
_logger.severe('Error following ${connection.name}: $error');
|
2022-12-19 18:59:33 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<void> rejectFollowRequest(Connection connection) async {
|
|
|
|
_logger.finest(
|
|
|
|
'Attempting to accept follow request ${connection.name}: ${connection.status}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile).rejectFollow(connection).match(
|
2022-12-19 18:59:33 +00:00
|
|
|
onSuccess: (update) {
|
|
|
|
_logger
|
|
|
|
.finest('Successfully followed ${update.name}: ${update.status}');
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-19 18:59:33 +00:00
|
|
|
notifyListeners();
|
|
|
|
},
|
|
|
|
onError: (error) {
|
2023-01-31 21:40:47 +00:00
|
|
|
_logger.severe('Error following ${connection.name}: $error');
|
2022-12-19 18:59:33 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<void> ignoreFollowRequest(Connection connection) async {
|
|
|
|
_logger.finest(
|
|
|
|
'Attempting to accept follow request ${connection.name}: ${connection.status}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile).ignoreFollow(connection).match(
|
2022-12-19 18:59:33 +00:00
|
|
|
onSuccess: (update) {
|
|
|
|
_logger
|
|
|
|
.finest('Successfully followed ${update.name}: ${update.status}');
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-19 18:59:33 +00:00
|
|
|
notifyListeners();
|
|
|
|
},
|
|
|
|
onError: (error) {
|
|
|
|
_logger.severe('Error following ${connection.name}');
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-12-14 15:50:17 +00:00
|
|
|
Future<void> follow(Connection connection) async {
|
|
|
|
_logger.finest(
|
|
|
|
'Attempting to follow ${connection.name}: ${connection.status}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile).followConnection(connection).match(
|
2022-12-14 15:50:17 +00:00
|
|
|
onSuccess: (update) {
|
|
|
|
_logger
|
|
|
|
.finest('Successfully followed ${update.name}: ${update.status}');
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-14 15:50:17 +00:00
|
|
|
notifyListeners();
|
|
|
|
},
|
|
|
|
onError: (error) {
|
|
|
|
_logger.severe('Error following ${connection.name}');
|
|
|
|
},
|
|
|
|
);
|
2022-12-08 18:37:30 +00:00
|
|
|
}
|
|
|
|
|
2022-12-14 15:50:17 +00:00
|
|
|
Future<void> unfollow(Connection connection) async {
|
|
|
|
_logger.finest(
|
|
|
|
'Attempting to unfollow ${connection.name}: ${connection.status}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile).unFollowConnection(connection).match(
|
2022-12-14 15:50:17 +00:00
|
|
|
onSuccess: (update) {
|
|
|
|
_logger
|
|
|
|
.finest('Successfully unfollowed ${update.name}: ${update.status}');
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-08 18:37:30 +00:00
|
|
|
notifyListeners();
|
|
|
|
},
|
|
|
|
onError: (error) {
|
2022-12-14 15:50:17 +00:00
|
|
|
_logger.severe('Error following ${connection.name}');
|
2022-12-08 18:37:30 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-01-18 05:15:52 +00:00
|
|
|
List<Connection> getMyContacts() {
|
2023-01-18 04:03:50 +00:00
|
|
|
return conRepo.getMyContacts();
|
2022-12-15 03:27:30 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 17:14:00 +00:00
|
|
|
Future<void> updateAllContacts(bool backgroundUpdate) async {
|
2022-12-15 03:27:30 +00:00
|
|
|
_logger.fine('Updating all contacts');
|
2023-04-28 02:05:10 +00:00
|
|
|
_lastUpdateStatus = 'Updating';
|
2023-04-28 18:23:01 +00:00
|
|
|
final persistentInfo = getIt<ActiveProfileSelector<PersistentInfoService>>()
|
|
|
|
.getForProfile(profile)
|
|
|
|
.value;
|
|
|
|
final originalTime = persistentInfo.lastMyConnectionsUpdate;
|
|
|
|
await persistentInfo.updateLastMyConnectionUpdate(DateTime.now());
|
2023-04-28 02:05:10 +00:00
|
|
|
notifyListeners();
|
2023-06-27 17:14:00 +00:00
|
|
|
final delay = backgroundUpdate
|
|
|
|
? const Duration(minutes: 5)
|
|
|
|
: const Duration(seconds: 10);
|
2023-04-28 18:23:01 +00:00
|
|
|
try {
|
|
|
|
final client = RelationshipsClient(profile);
|
|
|
|
final results = <String, Connection>{};
|
|
|
|
var moreResults = true;
|
|
|
|
var maxId = -1;
|
|
|
|
const limit = 50;
|
|
|
|
var currentPage = PagingData(limit: limit);
|
|
|
|
final originalContacts = conRepo.getMyContacts().toSet();
|
|
|
|
while (moreResults) {
|
|
|
|
await client.getMyFollowers(currentPage).match(onSuccess: (followers) {
|
|
|
|
for (final f in followers.data) {
|
|
|
|
originalContacts.remove(f);
|
|
|
|
results[f.id] = f.copy(status: ConnectionStatus.theyFollowYou);
|
|
|
|
int id = int.parse(f.id);
|
|
|
|
maxId = max(maxId, id);
|
|
|
|
}
|
|
|
|
if (followers.next != null) {
|
|
|
|
currentPage = followers.next!;
|
|
|
|
}
|
|
|
|
moreResults = followers.next != null;
|
|
|
|
}, onError: (error) {
|
|
|
|
_logger.severe('Error getting followers data: $error');
|
|
|
|
});
|
2023-06-27 17:14:00 +00:00
|
|
|
await Future.delayed(delay);
|
2023-04-28 18:23:01 +00:00
|
|
|
}
|
2022-12-15 03:27:30 +00:00
|
|
|
|
2023-04-28 18:23:01 +00:00
|
|
|
moreResults = true;
|
|
|
|
currentPage = PagingData(limit: limit);
|
|
|
|
while (moreResults) {
|
|
|
|
await client.getMyFollowing(currentPage).match(onSuccess: (following) {
|
|
|
|
for (final f in following.data) {
|
|
|
|
originalContacts.remove(f);
|
|
|
|
if (results.containsKey(f.id)) {
|
|
|
|
results[f.id] = f.copy(status: ConnectionStatus.mutual);
|
|
|
|
} else {
|
|
|
|
results[f.id] = f.copy(status: ConnectionStatus.youFollowThem);
|
|
|
|
}
|
|
|
|
int id = int.parse(f.id);
|
|
|
|
maxId = max(maxId, id);
|
2022-12-15 03:27:30 +00:00
|
|
|
}
|
2023-04-28 18:23:01 +00:00
|
|
|
if (following.next != null) {
|
|
|
|
currentPage = following.next!;
|
|
|
|
}
|
|
|
|
moreResults = following.next != null;
|
|
|
|
}, onError: (error) {
|
|
|
|
_logger.severe('Error getting followers data: $error');
|
|
|
|
});
|
2023-06-27 17:14:00 +00:00
|
|
|
await Future.delayed(delay);
|
2023-04-28 18:23:01 +00:00
|
|
|
}
|
2022-12-15 03:27:30 +00:00
|
|
|
|
2023-04-28 18:23:01 +00:00
|
|
|
for (final noLongerFollowed in originalContacts) {
|
|
|
|
results[noLongerFollowed.id] =
|
|
|
|
noLongerFollowed.copy(status: ConnectionStatus.none);
|
|
|
|
}
|
|
|
|
upsertAllConnections(results.values);
|
|
|
|
final myContacts = conRepo.getMyContacts().toList();
|
|
|
|
myContacts.sort((c1, c2) => c1.name.compareTo(c2.name));
|
|
|
|
await persistentInfo.updateLastMyConnectionUpdate(DateTime.now());
|
|
|
|
_logger.fine('# Contacts:${myContacts.length}');
|
|
|
|
} catch (e) {
|
|
|
|
await persistentInfo.updateLastMyConnectionUpdate(originalTime);
|
2023-04-19 00:59:51 +00:00
|
|
|
}
|
2023-04-28 18:23:01 +00:00
|
|
|
_lastUpdateStatus =
|
|
|
|
'Last updated at: ${persistentInfo.lastMyConnectionsUpdate}';
|
|
|
|
|
2022-12-15 03:27:30 +00:00
|
|
|
notifyListeners();
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
List<CircleData> getMyCircles() {
|
|
|
|
if (circlesNotInitialized) {
|
|
|
|
circlesNotInitialized = false;
|
|
|
|
_updateMyCircles(true);
|
2022-12-14 15:50:17 +00:00
|
|
|
}
|
2023-01-16 21:31:17 +00:00
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
return circlesRepo.getMyCircles();
|
2022-12-14 21:53:46 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
Result<List<Connection>, ExecError> getCircleMembers(CircleData circle) {
|
|
|
|
return circlesRepo
|
|
|
|
.getCircleMembers(circle)
|
2023-04-19 22:24:28 +00:00
|
|
|
.transform(
|
|
|
|
(members) => members
|
|
|
|
..sort((c1, c2) =>
|
|
|
|
c1.name.toLowerCase().compareTo(c2.name.toLowerCase())),
|
|
|
|
)
|
|
|
|
.execErrorCast();
|
2023-04-19 01:49:45 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
FutureResult<CircleData, ExecError> createCircle(String newName) async {
|
|
|
|
final result = await CirclesClient(profile)
|
|
|
|
.createCircle(newName)
|
|
|
|
.withResultAsync((newCircle) async {
|
|
|
|
circlesRepo.upsertCircle(newCircle);
|
2023-04-18 23:39:52 +00:00
|
|
|
notifyListeners();
|
|
|
|
});
|
|
|
|
return result.execErrorCast();
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
FutureResult<CircleData, ExecError> renameCircle(
|
2023-04-18 23:39:52 +00:00
|
|
|
String id, String newName) async {
|
2023-11-15 21:05:45 +00:00
|
|
|
final result = await CirclesClient(profile)
|
|
|
|
.renameCircle(id, newName)
|
|
|
|
.withResultAsync((renamedCircle) async {
|
|
|
|
circlesRepo.upsertCircle(renamedCircle);
|
2023-04-18 23:39:52 +00:00
|
|
|
notifyListeners();
|
|
|
|
});
|
|
|
|
return result.execErrorCast();
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
FutureResult<bool, ExecError> deleteCircle(CircleData circleData) async {
|
|
|
|
final result = await CirclesClient(profile)
|
|
|
|
.deleteCircle(circleData)
|
2023-04-18 23:39:52 +00:00
|
|
|
.withResultAsync((_) async {
|
2023-11-15 21:05:45 +00:00
|
|
|
circlesRepo.deleteCircle(circleData);
|
2023-04-18 23:39:52 +00:00
|
|
|
notifyListeners();
|
|
|
|
});
|
|
|
|
return result.execErrorCast();
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
void refreshCircles() {
|
|
|
|
_updateMyCircles(true);
|
2023-04-18 23:39:52 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
Future<void> refreshCircleMemberships(CircleData circle) async {
|
2023-04-19 01:49:45 +00:00
|
|
|
var page = PagingData(limit: 50);
|
2023-11-15 21:05:45 +00:00
|
|
|
final client = CirclesClient(profile);
|
2023-04-19 01:49:45 +00:00
|
|
|
final allResults = <Connection>{};
|
|
|
|
var moreResults = true;
|
|
|
|
while (moreResults) {
|
2023-11-15 21:05:45 +00:00
|
|
|
await client.getCircleMembers(circle, page).match(onSuccess: (results) {
|
2023-04-19 01:49:45 +00:00
|
|
|
moreResults = results.data.isNotEmpty && results.next != null;
|
|
|
|
page = results.next ?? page;
|
|
|
|
allResults.addAll(results.data);
|
|
|
|
}, onError: (error) {
|
2023-11-15 21:05:45 +00:00
|
|
|
_logger.severe('Error getting circle listing data: $error');
|
2023-04-19 01:49:45 +00:00
|
|
|
moreResults = false;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
circlesRepo.deleteCircle(circle);
|
|
|
|
circlesRepo.upsertCircle(circle);
|
2023-04-19 01:49:45 +00:00
|
|
|
for (final c in allResults) {
|
|
|
|
upsertConnection(c);
|
2023-11-15 21:05:45 +00:00
|
|
|
circlesRepo.addConnectionToCircle(circle, c);
|
2023-04-19 01:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
notifyListeners();
|
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
Result<List<CircleData>, ExecError> getCirclesForUser(String id) {
|
|
|
|
final result = circlesRepo.getCirclesForUser(id);
|
2023-01-16 21:31:17 +00:00
|
|
|
if (result.isSuccess) {
|
2023-11-15 21:05:45 +00:00
|
|
|
print("Circles for user $id: $result");
|
2023-01-16 21:31:17 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (result.isFailure && result.error.type != ErrorType.notFound) {
|
|
|
|
return result;
|
2022-12-14 21:53:46 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
_refreshCircleListData(id, true);
|
2023-01-16 21:31:17 +00:00
|
|
|
return Result.ok(UnmodifiableListView([]));
|
2022-12-14 21:53:46 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
FutureResult<bool, ExecError> addUserToCircle(
|
|
|
|
CircleData circle, Connection connection) async {
|
|
|
|
_logger.finest('Adding ${connection.name} to circle: ${circle.name}');
|
|
|
|
return await CirclesClient(profile)
|
|
|
|
.addConnectionToCircle(circle, connection)
|
|
|
|
.withResultAsync((_) async => await refreshCircleMemberships(circle))
|
2023-04-21 13:54:31 +00:00
|
|
|
.withResult((_) => notifyListeners())
|
|
|
|
.mapError((error) {
|
2023-11-15 21:05:45 +00:00
|
|
|
_logger.severe(
|
|
|
|
'Error adding ${connection.name} from circle: ${circle.name}');
|
2023-04-21 13:54:31 +00:00
|
|
|
return error;
|
|
|
|
});
|
2022-12-14 21:53:46 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
FutureResult<bool, ExecError> removeUserFromCircle(
|
|
|
|
CircleData circle, Connection connection) async {
|
|
|
|
_logger.finest('Removing ${connection.name} from circle: ${circle.name}');
|
|
|
|
return CirclesClient(profile)
|
|
|
|
.removeConnectionFromCircle(circle, connection)
|
|
|
|
.withResultAsync((_) async => await refreshCircleMemberships(circle))
|
2023-04-21 13:54:31 +00:00
|
|
|
.withResult((_) => notifyListeners())
|
2023-04-20 16:14:04 +00:00
|
|
|
.mapError(
|
|
|
|
(error) {
|
2022-12-14 21:53:46 +00:00
|
|
|
_logger.severe(
|
2023-11-15 21:05:45 +00:00
|
|
|
'Error removing ${connection.name} from circle: ${circle.name}');
|
2023-04-20 16:14:04 +00:00
|
|
|
return error;
|
2022-12-14 21:53:46 +00:00
|
|
|
},
|
|
|
|
);
|
2022-12-14 15:50:17 +00:00
|
|
|
}
|
|
|
|
|
2023-04-28 01:48:01 +00:00
|
|
|
Result<Connection, ExecError> getById(String id, {bool forceUpdate = false}) {
|
2023-05-03 19:49:40 +00:00
|
|
|
return conRepo.getById(id).transform((c) {
|
|
|
|
if (c.status == ConnectionStatus.unknown && forceUpdate) {
|
2023-01-16 21:31:17 +00:00
|
|
|
_refreshConnection(c, true);
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}).execErrorCast();
|
2022-11-18 21:50:15 +00:00
|
|
|
}
|
|
|
|
|
2023-01-16 21:31:17 +00:00
|
|
|
Result<Connection, ExecError> getByName(String name) {
|
2023-01-18 04:03:50 +00:00
|
|
|
return conRepo.getByName(name).andThenSuccess((c) {
|
2023-01-16 21:31:17 +00:00
|
|
|
if (c.status == ConnectionStatus.unknown) {
|
|
|
|
_refreshConnection(c, true);
|
2023-01-25 18:51:53 +00:00
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}).execErrorCast();
|
|
|
|
}
|
|
|
|
|
|
|
|
Result<Connection, ExecError> getByHandle(String handle) {
|
|
|
|
return conRepo.getByHandle(handle).andThenSuccess((c) {
|
|
|
|
if (c.status == ConnectionStatus.unknown) {
|
|
|
|
_refreshConnection(c, true);
|
2023-01-16 21:31:17 +00:00
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}).execErrorCast();
|
2022-12-14 15:50:17 +00:00
|
|
|
}
|
|
|
|
|
2023-05-03 21:32:21 +00:00
|
|
|
Future<void> fullRefresh(
|
|
|
|
Connection connection, {
|
|
|
|
bool withNotifications = true,
|
|
|
|
}) async {
|
2023-11-15 21:05:45 +00:00
|
|
|
await _updateMyCircles(false);
|
|
|
|
await _refreshCircleListData(connection.id, false);
|
2022-12-14 21:53:46 +00:00
|
|
|
await _refreshConnection(connection, false);
|
2023-05-03 21:32:21 +00:00
|
|
|
if (withNotifications) {
|
|
|
|
notifyListeners();
|
|
|
|
}
|
2022-12-14 21:53:46 +00:00
|
|
|
}
|
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
Future<void> _refreshCircleListData(String id, bool withNotification) async {
|
2022-12-14 15:50:17 +00:00
|
|
|
_logger.finest('Refreshing member list data for Connection $id');
|
2023-11-15 21:05:45 +00:00
|
|
|
await CirclesClient(profile).getMemberCirclesForConnection(id).match(
|
|
|
|
onSuccess: (circles) {
|
|
|
|
circlesRepo.updateConnectionCircleData(id, circles);
|
2022-12-14 21:53:46 +00:00
|
|
|
if (withNotification) {
|
|
|
|
notifyListeners();
|
|
|
|
}
|
2022-12-14 15:50:17 +00:00
|
|
|
},
|
|
|
|
onError: (error) {
|
|
|
|
_logger.severe('Error getting list data for $id: $error');
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
2022-11-18 21:50:15 +00:00
|
|
|
|
2022-12-14 21:53:46 +00:00
|
|
|
Future<void> _refreshConnection(
|
|
|
|
Connection connection, bool withNotification) async {
|
2022-12-14 15:50:17 +00:00
|
|
|
_logger.finest('Refreshing connection data for ${connection.name}');
|
2023-04-28 18:23:01 +00:00
|
|
|
await RelationshipsClient(profile)
|
2023-02-24 20:56:39 +00:00
|
|
|
.getConnectionWithStatus(connection)
|
2022-12-14 15:50:17 +00:00
|
|
|
.match(
|
|
|
|
onSuccess: (update) {
|
2023-04-19 00:33:09 +00:00
|
|
|
upsertConnection(update);
|
2022-12-14 21:53:46 +00:00
|
|
|
if (withNotification) {
|
|
|
|
notifyListeners();
|
|
|
|
}
|
2022-12-14 15:50:17 +00:00
|
|
|
},
|
|
|
|
onError: (error) {
|
|
|
|
_logger.severe('Error getting updates for ${connection.name}: $error');
|
|
|
|
},
|
|
|
|
);
|
2022-11-18 21:50:15 +00:00
|
|
|
}
|
2022-12-14 21:53:46 +00:00
|
|
|
|
2023-11-15 21:05:45 +00:00
|
|
|
Future<void> _updateMyCircles(bool withNotification) async {
|
|
|
|
_logger.finest('Refreshing my circles list');
|
|
|
|
await CirclesClient(profile).getCircles().match(
|
|
|
|
onSuccess: (circles) {
|
|
|
|
_logger.finest('Got updated circles:${circles.map((e) => e.name)}');
|
|
|
|
circlesRepo.clearMyCircles();
|
|
|
|
circlesRepo.addAllCircles(circles);
|
2022-12-14 21:53:46 +00:00
|
|
|
if (withNotification) {
|
|
|
|
notifyListeners();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
onError: (error) {
|
2023-11-15 21:05:45 +00:00
|
|
|
_logger.severe('Error getting my circles: $error');
|
2022-12-14 21:53:46 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
2022-11-18 21:50:15 +00:00
|
|
|
}
|