ember/fluffychat
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Splits extensions into multiple smaller files

Browse source
This commit is contained in:
Kelrap 2024-05-24 09:19:37 -04:00
parent 629b5e48e3
commit d668a9b73f
17 changed files with 1801 additions and 1444 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
lib/pages/chat/chat_event_list.dart
View file

@ -81,7 +81,7 @@ class ChatEventList extends StatelessWidget {
// #Pangea
if (i == 1) {
return (controller.room.locked) && !controller.room.isRoomAdmin
return (controller.room.isLocked) && !controller.room.isRoomAdmin
? const LockedChatMessage()
: const SizedBox.shrink();
}

4
lib/pages/chat_details/chat_details_view.dart
View file

@ -585,12 +585,12 @@ class ChatDetailsView extends StatelessWidget {
Theme.of(context).scaffoldBackgroundColor,
foregroundColor: iconColor,
child: Icon(
room.locked
room.isLocked
? Icons.lock_outlined
: Icons.no_encryption_outlined,
),
),
value: room.locked,
value: room.isLocked,
onChanged: (value) => showFutureLoadingDialog(
context: context,
future: () => value

2
lib/pages/chat_list/chat_list_item.dart
View file

@ -256,7 +256,7 @@ class ChatListItem extends StatelessWidget {
),
const SizedBox(width: 8),
// #Pangea
if (room.locked)
if (room.isLocked)
const Padding(
padding: EdgeInsets.only(right: 4.0),
child: Icon(

2
lib/pages/chat_list/space_view.dart
View file

@ -603,7 +603,7 @@ class _SpaceViewState extends State<SpaceView> {
subtitle: Row(
children: [
spaceSubtitle(rootSpace),
if (rootSpace.locked)
if (rootSpace.isLocked)
const Padding(
padding: EdgeInsets.only(left: 4.0),
child: Icon(

2
lib/pangea/controllers/class_controller.dart
View file

@ -36,7 +36,7 @@ class ClassController extends BaseController {
final List<Future<void>> classFixes = [];
for (final room in (await _pangeaController
.matrixState.client.classesAndExchangesImTeaching)) {
classFixes.add(room.setClassPowerlLevels());
classFixes.add(room.setClassPowerLevels());
}
await Future.wait(classFixes);
} catch (err, stack) {

339
lib/pangea/extensions/client_extension.dart
View file

@ -13,323 +13,78 @@ import 'package:matrix/matrix.dart';
import '../utils/p_store.dart';
part "client_extension/analytics.dart";
part "client_extension/classes_and_exchanges.dart";
part "client_extension/general_info.dart";
extension PangeaClient on Client {
List<Room> get classes => rooms.where((e) => e.isPangeaClass).toList();
// analytics
List<Room> get classesImTeaching => rooms
.where(
(e) =>
e.isPangeaClass &&
e.ownPowerLevel == ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
Future<Room> getMyAnalyticsRoom(String langCode) async =>
await _getMyAnalyticsRoom(langCode);
Future<List<Room>> get classesAndExchangesImTeaching async {
for (final Room space in rooms.where((room) => room.isSpace)) {
if (space.getState(EventTypes.RoomPowerLevels) == null) {
await space.postLoad();
}
}
Room? analyticsRoomLocal(String? langCode, [String? userIdParam]) =>
_analyticsRoomLocal(langCode, userIdParam);
final spaces = rooms
.where(
(e) =>
(e.isPangeaClass || e.isExchange) &&
e.ownPowerLevel == ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
return spaces;
}
List<Room> get allMyAnalyticsRooms => _allMyAnalyticsRooms;
List<Room> get classesImIn => rooms
.where(
(e) =>
e.isPangeaClass &&
e.ownPowerLevel < ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
Future<List<Room>> get classesAndExchangesImStudyingIn async {
for (final Room space in rooms.where((room) => room.isSpace)) {
if (space.getState(EventTypes.RoomPowerLevels) == null) {
await space.postLoad();
}
}
final spaces = rooms
.where(
(e) =>
(e.isPangeaClass || e.isExchange) &&
e.ownPowerLevel < ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
return spaces;
}
List<Room> get classesAndExchangesImIn =>
rooms.where((e) => e.isPangeaClass || e.isExchange).toList();
Future<List<String>> get teacherRoomIds async {
final List<String> adminRoomIds = [];
for (final Room adminSpace in (await classesAndExchangesImTeaching)) {
adminRoomIds.add(adminSpace.id);
final children = adminSpace.childrenAndGrandChildren;
final List<String> adminSpaceRooms = children
.where((e) => e.roomId != null)
.map((e) => e.roomId!)
.toList();
adminRoomIds.addAll(adminSpaceRooms);
}
return adminRoomIds;
}
Future<List<User>> get myTeachers async {
final List<User> teachers = [];
for (final classRoom in classesAndExchangesImIn) {
for (final teacher in await classRoom.teachers) {
// If person requesting list of teachers is a teacher in another classroom, don't add them to the list
if (!teachers.any((e) => e.id == teacher.id) && userID != teacher.id) {
teachers.add(teacher);
}
}
}
return teachers;
}
Future<void> updateAnalyticsRoomVisibility() async =>
await _updateAnalyticsRoomVisibility();
Future<void> updateMyLearningAnalyticsForAllClassesImIn([
PLocalStore? storageService,
]) async {
try {
final List<Future<void>> updateFutures = [];
for (final classRoom in classesAndExchangesImIn) {
updateFutures
.add(classRoom.updateMyLearningAnalyticsForClass(storageService));
}
await Future.wait(updateFutures);
} catch (err, s) {
if (kDebugMode) rethrow;
// debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: s);
}
}
]) async =>
await _updateMyLearningAnalyticsForAllClassesImIn(storageService);
// get analytics room matching targetlanguage
// if not present, create it and invite teachers of that language
// set description to let people know what the hell it is
Future<Room> getMyAnalyticsRoom(String langCode) async {
await roomsLoading;
// ensure room state events (room create,
// to check for analytics type) are loaded
for (final room in rooms) {
if (room.partial) await room.postLoad();
}
Future<void> addAnalyticsRoomsToAllSpaces() async =>
await _addAnalyticsRoomsToAllSpaces();
final Room? analyticsRoom = analyticsRoomLocal(langCode);
Future<void> inviteAllTeachersToAllAnalyticsRooms() async =>
await _inviteAllTeachersToAllAnalyticsRooms();
if (analyticsRoom != null) return analyticsRoom;
Future<void> joinAnalyticsRoomsInAllSpaces() async =>
await _joinAnalyticsRoomsInAllSpaces();
return _makeAnalyticsRoom(langCode);
}
Future<void> joinInvitedAnalyticsRooms() async =>
await _joinInvitedAnalyticsRooms();
//note: if langCode is null and user has >1 analyticsRooms then this could
//return the wrong one. this is to account for when an exchange might not
//be in a class.
Room? analyticsRoomLocal(String? langCode, [String? userIdParam]) {
final Room? analyticsRoom = rooms.firstWhereOrNull((e) {
return e.isAnalyticsRoom &&
e.isAnalyticsRoomOfUser(userIdParam ?? userID!) &&
(langCode != null ? e.isMadeForLang(langCode) : true);
});
if (analyticsRoom != null &&
analyticsRoom.membership == Membership.invite) {
debugger(when: kDebugMode);
analyticsRoom
.join()
.onError(
(error, stackTrace) =>
ErrorHandler.logError(e: error, s: stackTrace),
)
.then((value) => analyticsRoom.postLoad());
return analyticsRoom;
}
return analyticsRoom;
}
Future<void> migrateAnalyticsRooms() async => await _migrateAnalyticsRooms();
Future<Room> _makeAnalyticsRoom(String langCode) async {
final String roomID = await createRoom(
creationContent: {
'type': PangeaRoomTypes.analytics,
ModelKey.langCode: langCode,
},
name: "$userID $langCode Analytics",
topic: "This room stores learning analytics for $userID.",
invite: [
...(await myTeachers).map((e) => e.id),
// BotName.localBot,
BotName.byEnvironment,
],
);
if (getRoomById(roomID) == null) {
// Wait for room actually appears in sync
await waitForRoomInSync(roomID, join: true);
}
// classes_and_exchanges
final Room? analyticsRoom = getRoomById(roomID);
List<Room> get classes => _classes;
// add this analytics room to all spaces so teachers can join them
// via the space hierarchy
await analyticsRoom?.addAnalyticsRoomToSpaces();
List<Room> get classesImTeaching => _classesImTeaching;
// and invite all teachers to new analytics room
await analyticsRoom?.inviteTeachersToAnalyticsRoom();
return getRoomById(roomID)!;
}
Future<List<Room>> get classesAndExchangesImTeaching async =>
await _classesAndExchangesImTeaching;
Future<Room> getReportsDM(User teacher, Room space) async {
final String roomId = await teacher.startDirectChat(
enableEncryption: false,
);
space.setSpaceChild(
roomId,
suggested: false,
);
return getRoomById(roomId)!;
}
List<Room> get classesImIn => _classesImIn;
Future<List<Room>> get classesAndExchangesImStudyingIn async =>
await _classesAndExchangesImStudyingIn;
List<Room> get classesAndExchangesImIn => _classesAndExchangesImIn;
Future<PangeaRoomRules?> get lastUpdatedRoomRules async =>
(await classesAndExchangesImTeaching)
.where((space) => space.rulesUpdatedAt != null)
.sorted(
(a, b) => b.rulesUpdatedAt!.compareTo(a.rulesUpdatedAt!),
)
.firstOrNull
?.pangeaRoomRules;
await _lastUpdatedRoomRules;
ClassSettingsModel? get lastUpdatedClassSettings => classesImTeaching
.where((space) => space.classSettingsUpdatedAt != null)
.sorted(
(a, b) =>
b.classSettingsUpdatedAt!.compareTo(a.classSettingsUpdatedAt!),
)
.firstOrNull
?.classSettings;
ClassSettingsModel? get lastUpdatedClassSettings => _lastUpdatedClassSettings;
Future<bool> get hasBotDM async {
final List<Room> chats = rooms
.where((room) => !room.isSpace && room.membership == Membership.join)
.toList();
// general_info
for (final Room chat in chats) {
if (await chat.isBotDM) return true;
}
return false;
}
Future<List<String>> get teacherRoomIds async => await _teacherRoomIds;
Future<List<User>> get myTeachers async => await _myTeachers;
Future<Room> getReportsDM(User teacher, Room space) async =>
await _getReportsDM(teacher, space);
Future<bool> get hasBotDM async => await _hasBotDM;
Future<List<String>> getEditHistory(
String roomId,
String eventId,
) async {
final Room? room = getRoomById(roomId);
final Event? editEvent = await room?.getEventById(eventId);
final String? edittedEventId =
editEvent?.content.tryGetMap('m.relates_to')?['event_id'];
if (edittedEventId == null) return [];
final Event? originalEvent = await room!.getEventById(edittedEventId);
if (originalEvent == null) return [];
final Timeline timeline = await room.getTimeline();
final List<Event> editEvents = originalEvent
.aggregatedEvents(
timeline,
RelationshipTypes.edit,
)
.sorted(
(a, b) => b.originServerTs.compareTo(a.originServerTs),
)
.toList();
editEvents.add(originalEvent);
return editEvents.slice(1).map((e) => e.eventId).toList();
}
// Get all my analytics rooms
List<Room> get allMyAnalyticsRooms => rooms
.where(
(e) => e.isAnalyticsRoomOfUser(userID!),
)
.toList();
// migration function to change analytics rooms' vsibility to public
// so they will appear in the space hierarchy
Future<void> updateAnalyticsRoomVisibility() async {
final List<Future> makePublicFutures = [];
for (final Room room in allMyAnalyticsRooms) {
final visability = await getRoomVisibilityOnDirectory(room.id);
if (visability != Visibility.public) {
await setRoomVisibilityOnDirectory(
room.id,
visibility: Visibility.public,
);
}
}
await Future.wait(makePublicFutures);
}
// Add all the users' analytics room to all the spaces the student studies in
// So teachers can join them via space hierarchy
// Will not always work, as there may be spaces where students don't have permission to add chats
// But allows teachers to join analytics rooms without being invited
Future<void> addAnalyticsRoomsToAllSpaces() async {
final List<Future> addFutures = [];
for (final Room room in allMyAnalyticsRooms) {
addFutures.add(room.addAnalyticsRoomToSpaces());
}
await Future.wait(addFutures);
}
// Invite teachers to all my analytics room
// Handles case when students cannot add analytics room to space(s)
// So teacher is still able to get analytics data for this student
Future<void> inviteAllTeachersToAllAnalyticsRooms() async {
final List<Future> inviteFutures = [];
for (final Room analyticsRoom in allMyAnalyticsRooms) {
inviteFutures.add(analyticsRoom.inviteTeachersToAnalyticsRoom());
}
await Future.wait(inviteFutures);
}
// Join all analytics rooms in all spaces
// Allows teachers to join analytics rooms without being invited
Future<void> joinAnalyticsRoomsInAllSpaces() async {
final List<Future> joinFutures = [];
for (final Room space in (await classesAndExchangesImTeaching)) {
joinFutures.add(space.joinAnalyticsRoomsInSpace());
}
await Future.wait(joinFutures);
}
// Join invited analytics rooms
// Checks for invites to any student analytics rooms
// Handles case of analytics rooms that can't be added to some space(s)
Future<void> joinInvitedAnalyticsRooms() async {
for (final Room room in rooms) {
if (room.membership == Membership.invite && room.isAnalyticsRoom) {
try {
await room.join();
} catch (err) {
debugPrint("Failed to join analytics room ${room.id}");
}
}
}
}
// helper function to join all relevant analytics rooms
// and set up those rooms to be joined by relevant teachers
Future<void> migrateAnalyticsRooms() async {
await updateAnalyticsRoomVisibility();
await addAnalyticsRoomsToAllSpaces();
await inviteAllTeachersToAllAnalyticsRooms();
await joinInvitedAnalyticsRooms();
await joinAnalyticsRoomsInAllSpaces();
}
) async =>
await _getEditHistory(roomId, eventId);
}

173
lib/pangea/extensions/client_extension/analytics.dart Normal file
View file

@ -0,0 +1,173 @@
part of "../client_extension.dart";
extension PangeaClient1 on Client {
// get analytics room matching targetlanguage
// if not present, create it and invite teachers of that language
// set description to let people know what the hell it is
Future<Room> _getMyAnalyticsRoom(String langCode) async {
await roomsLoading;
// ensure room state events (room create,
// to check for analytics type) are loaded
for (final room in rooms) {
if (room.partial) await room.postLoad();
}
final Room? analyticsRoom = analyticsRoomLocal(langCode);
if (analyticsRoom != null) return analyticsRoom;
return _makeAnalyticsRoom(langCode);
}
//note: if langCode is null and user has >1 analyticsRooms then this could
//return the wrong one. this is to account for when an exchange might not
//be in a class.
Room? _analyticsRoomLocal(String? langCode, [String? userIdParam]) {
final Room? analyticsRoom = rooms.firstWhereOrNull((e) {
return e.isAnalyticsRoom &&
e.isAnalyticsRoomOfUser(userIdParam ?? userID!) &&
(langCode != null ? e.isMadeForLang(langCode) : true);
});
if (analyticsRoom != null &&
analyticsRoom.membership == Membership.invite) {
debugger(when: kDebugMode);
analyticsRoom
.join()
.onError(
(error, stackTrace) =>
ErrorHandler.logError(e: error, s: stackTrace),
)
.then((value) => analyticsRoom.postLoad());
return analyticsRoom;
}
return analyticsRoom;
}
Future<Room> _makeAnalyticsRoom(String langCode) async {
final String roomID = await createRoom(
creationContent: {
'type': PangeaRoomTypes.analytics,
ModelKey.langCode: langCode,
},
name: "$userID $langCode Analytics",
topic: "This room stores learning analytics for $userID.",
invite: [
...(await myTeachers).map((e) => e.id),
// BotName.localBot,
BotName.byEnvironment,
],
);
if (getRoomById(roomID) == null) {
// Wait for room actually appears in sync
await waitForRoomInSync(roomID, join: true);
}
final Room? analyticsRoom = getRoomById(roomID);
// add this analytics room to all spaces so teachers can join them
// via the space hierarchy
await analyticsRoom?.addAnalyticsRoomToSpaces();
// and invite all teachers to new analytics room
await analyticsRoom?.inviteTeachersToAnalyticsRoom();
return getRoomById(roomID)!;
}
// Get all my analytics rooms
List<Room> get _allMyAnalyticsRooms => rooms
.where(
(e) => e.isAnalyticsRoomOfUser(userID!),
)
.toList();
// migration function to change analytics rooms' vsibility to public
// so they will appear in the space hierarchy
Future<void> _updateAnalyticsRoomVisibility() async {
final List<Future> makePublicFutures = [];
for (final Room room in allMyAnalyticsRooms) {
final visability = await getRoomVisibilityOnDirectory(room.id);
if (visability != Visibility.public) {
await setRoomVisibilityOnDirectory(
room.id,
visibility: Visibility.public,
);
}
}
await Future.wait(makePublicFutures);
}
Future<void> _updateMyLearningAnalyticsForAllClassesImIn([
PLocalStore? storageService,
]) async {
try {
final List<Future<void>> updateFutures = [];
for (final classRoom in classesAndExchangesImIn) {
updateFutures
.add(classRoom.updateMyLearningAnalyticsForClass(storageService));
}
await Future.wait(updateFutures);
} catch (err, s) {
if (kDebugMode) rethrow;
// debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: s);
}
}
// Add all the users' analytics room to all the spaces the student studies in
// So teachers can join them via space hierarchy
// Will not always work, as there may be spaces where students don't have permission to add chats
// But allows teachers to join analytics rooms without being invited
Future<void> _addAnalyticsRoomsToAllSpaces() async {
final List<Future> addFutures = [];
for (final Room room in allMyAnalyticsRooms) {
addFutures.add(room.addAnalyticsRoomToSpaces());
}
await Future.wait(addFutures);
}
// Invite teachers to all my analytics room
// Handles case when students cannot add analytics room to space(s)
// So teacher is still able to get analytics data for this student
Future<void> _inviteAllTeachersToAllAnalyticsRooms() async {
final List<Future> inviteFutures = [];
for (final Room analyticsRoom in allMyAnalyticsRooms) {
inviteFutures.add(analyticsRoom.inviteTeachersToAnalyticsRoom());
}
await Future.wait(inviteFutures);
}
// Join all analytics rooms in all spaces
// Allows teachers to join analytics rooms without being invited
Future<void> _joinAnalyticsRoomsInAllSpaces() async {
final List<Future> joinFutures = [];
for (final Room space in (await _classesAndExchangesImTeaching)) {
joinFutures.add(space.joinAnalyticsRoomsInSpace());
}
await Future.wait(joinFutures);
}
// Join invited analytics rooms
// Checks for invites to any student analytics rooms
// Handles case of analytics rooms that can't be added to some space(s)
Future<void> _joinInvitedAnalyticsRooms() async {
for (final Room room in rooms) {
if (room.membership == Membership.invite && room.isAnalyticsRoom) {
try {
await room.join();
} catch (err) {
debugPrint("Failed to join analytics room ${room.id}");
}
}
}
}
// helper function to join all relevant analytics rooms
// and set up those rooms to be joined by relevant teachers
Future<void> _migrateAnalyticsRooms() async {
await _updateAnalyticsRoomVisibility();
await _addAnalyticsRoomsToAllSpaces();
await _inviteAllTeachersToAllAnalyticsRooms();
await _joinInvitedAnalyticsRooms();
await _joinAnalyticsRoomsInAllSpaces();
}
}

76
lib/pangea/extensions/client_extension/classes_and_exchanges.dart Normal file
View file

@ -0,0 +1,76 @@
part of "../client_extension.dart";
extension PangeaClient2 on Client {
List<Room> get _classes => rooms.where((e) => e.isPangeaClass).toList();
List<Room> get _classesImTeaching => rooms
.where(
(e) =>
e.isPangeaClass &&
e.ownPowerLevel == ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
Future<List<Room>> get _classesAndExchangesImTeaching async {
for (final Room space in rooms.where((room) => room.isSpace)) {
if (space.getState(EventTypes.RoomPowerLevels) == null) {
await space.postLoad();
}
}
final spaces = rooms
.where(
(e) =>
(e.isPangeaClass || e.isExchange) &&
e.ownPowerLevel == ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
return spaces;
}
List<Room> get _classesImIn => rooms
.where(
(e) =>
e.isPangeaClass &&
e.ownPowerLevel < ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
Future<List<Room>> get _classesAndExchangesImStudyingIn async {
for (final Room space in rooms.where((room) => room.isSpace)) {
if (space.getState(EventTypes.RoomPowerLevels) == null) {
await space.postLoad();
}
}
final spaces = rooms
.where(
(e) =>
(e.isPangeaClass || e.isExchange) &&
e.ownPowerLevel < ClassDefaultValues.powerLevelOfAdmin,
)
.toList();
return spaces;
}
List<Room> get _classesAndExchangesImIn =>
rooms.where((e) => e.isPangeaClass || e.isExchange).toList();
Future<PangeaRoomRules?> get _lastUpdatedRoomRules async =>
(await _classesAndExchangesImTeaching)
.where((space) => space.rulesUpdatedAt != null)
.sorted(
(a, b) => b.rulesUpdatedAt!.compareTo(a.rulesUpdatedAt!),
)
.firstOrNull
?.pangeaRoomRules;
ClassSettingsModel? get _lastUpdatedClassSettings => classesImTeaching
.where((space) => space.classSettingsUpdatedAt != null)
.sorted(
(a, b) =>
b.classSettingsUpdatedAt!.compareTo(a.classSettingsUpdatedAt!),
)
.firstOrNull
?.classSettings;
}

79
lib/pangea/extensions/client_extension/general_info.dart Normal file
View file

@ -0,0 +1,79 @@
part of "../client_extension.dart";
extension PangeaClient3 on Client {
Future<List<String>> get _teacherRoomIds async {
final List<String> adminRoomIds = [];
for (final Room adminSpace in (await _classesAndExchangesImTeaching)) {
adminRoomIds.add(adminSpace.id);
final children = adminSpace.childrenAndGrandChildren;
final List<String> adminSpaceRooms = children
.where((e) => e.roomId != null)
.map((e) => e.roomId!)
.toList();
adminRoomIds.addAll(adminSpaceRooms);
}
return adminRoomIds;
}
Future<List<User>> get _myTeachers async {
final List<User> teachers = [];
for (final classRoom in classesAndExchangesImIn) {
for (final teacher in await classRoom.teachers) {
// If person requesting list of teachers is a teacher in another classroom, don't add them to the list
if (!teachers.any((e) => e.id == teacher.id) && userID != teacher.id) {
teachers.add(teacher);
}
}
}
return teachers;
}
Future<Room> _getReportsDM(User teacher, Room space) async {
final String roomId = await teacher.startDirectChat(
enableEncryption: false,
);
space.setSpaceChild(
roomId,
suggested: false,
);
return getRoomById(roomId)!;
}
Future<bool> get _hasBotDM async {
final List<Room> chats = rooms
.where((room) => !room.isSpace && room.membership == Membership.join)
.toList();
for (final Room chat in chats) {
if (await chat.isBotDM) return true;
}
return false;
}
Future<List<String>> _getEditHistory(
String roomId,
String eventId,
) async {
final Room? room = getRoomById(roomId);
final Event? editEvent = await room?.getEventById(eventId);
final String? edittedEventId =
editEvent?.content.tryGetMap('m.relates_to')?['event_id'];
if (edittedEventId == null) return [];
final Event? originalEvent = await room!.getEventById(edittedEventId);
if (originalEvent == null) return [];
final Timeline timeline = await room.getTimeline();
final List<Event> editEvents = originalEvent
.aggregatedEvents(
timeline,
RelationshipTypes.edit,
)
.sorted(
(a, b) => b.originServerTs.compareTo(a.originServerTs),
)
.toList();
editEvents.add(originalEvent);
return editEvents.slice(1).map((e) => e.eventId).toList();
}
}

1318
lib/pangea/extensions/pangea_room_extension.dart
View file

File diff suppressed because it is too large Load diff

376
lib/pangea/extensions/pangea_room_extension/analytics.dart Normal file
View file

@ -0,0 +1,376 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom1 on Room {
// Join analytics rooms in space
// Allows teachers to join analytics rooms without being invited
Future<void> _joinAnalyticsRoomsInSpace() async {
if (!isSpace) {
debugPrint("joinAnalyticsRoomsInSpace called on non-space room");
Sentry.addBreadcrumb(
Breadcrumb(
message: "joinAnalyticsRoomsInSpace called on non-space room",
),
);
return;
}
// added delay because without it power levels don't load and user is not
// recognized as admin
await Future.delayed(const Duration(milliseconds: 500));
await postLoad();
if (!isRoomAdmin) {
debugPrint("joinAnalyticsRoomsInSpace called by non-admin");
Sentry.addBreadcrumb(
Breadcrumb(
message: "joinAnalyticsRoomsInSpace called by non-admin",
),
);
return;
}
final spaceHierarchy = await client.getSpaceHierarchy(
id,
maxDepth: 1,
);
final List<String> analyticsRoomIds = spaceHierarchy.rooms
.where(
(r) => r.roomType == PangeaRoomTypes.analytics,
)
.map((r) => r.roomId)
.toList();
for (final String roomID in analyticsRoomIds) {
try {
await joinSpaceChild(roomID);
} catch (err, s) {
debugPrint("Failed to join analytics room $roomID in space $id");
ErrorHandler.logError(
e: err,
m: "Failed to join analytics room $roomID in space $id",
s: s,
);
}
}
}
// check if analytics room exists for a given language code
// and if not, create it
Future<void> _ensureAnalyticsRoomExists() async {
await postLoad();
if (firstLanguageSettings?.targetLanguage == null) return;
await client.getMyAnalyticsRoom(firstLanguageSettings!.targetLanguage);
}
// add 1 analytics room to 1 space
Future<void> _addAnalyticsRoomToSpace(Room analyticsRoom) async {
if (!isSpace) {
debugPrint("addAnalyticsRoomToSpace called on non-space room");
Sentry.addBreadcrumb(
Breadcrumb(
message: "addAnalyticsRoomToSpace called on non-space room",
),
);
return Future.value();
}
if (spaceChildren.any((sc) => sc.roomId == analyticsRoom.id)) return;
if (canIAddSpaceChild(null)) {
try {
await setSpaceChild(analyticsRoom.id);
} catch (err) {
debugPrint(
"Failed to add analytics room ${analyticsRoom.id} for student to space $id",
);
Sentry.addBreadcrumb(
Breadcrumb(
message: "Failed to add analytics room to space $id",
),
);
}
}
}
// Add analytics room to all spaces the user is a student in (1 analytics room to all spaces)
// So teachers can join them via space hierarchy
// Will not always work, as there may be spaces where students don't have permission to add chats
// But allows teachers to join analytics rooms without being invited
Future<void> _addAnalyticsRoomToSpaces() async {
if (!isAnalyticsRoomOfUser(client.userID!)) {
debugPrint("addAnalyticsRoomToSpaces called on non-analytics room");
Sentry.addBreadcrumb(
Breadcrumb(
message: "addAnalyticsRoomToSpaces called on non-analytics room",
),
);
return;
}
for (final Room space in (await client.classesAndExchangesImStudyingIn)) {
if (space.spaceChildren.any((sc) => sc.roomId == id)) continue;
await space.addAnalyticsRoomToSpace(this);
}
}
// Add all analytics rooms to space
// Similar to addAnalyticsRoomToSpaces, but all analytics room to 1 space
Future<void> _addAnalyticsRoomsToSpace() async {
await postLoad();
final List<Room> allMyAnalyticsRooms = client.allMyAnalyticsRooms;
for (final Room analyticsRoom in allMyAnalyticsRooms) {
await addAnalyticsRoomToSpace(analyticsRoom);
}
}
StudentAnalyticsEvent? _getStudentAnalyticsLocal(String studentId) {
if (!isSpace) {
debugger(when: kDebugMode);
ErrorHandler.logError(
m: "calling getStudentAnalyticsLocal on non-space room",
s: StackTrace.current,
);
return null;
}
final Event? matrixEvent = getState(
PangeaEventTypes.studentAnalyticsSummary,
studentId,
);
return matrixEvent != null
? StudentAnalyticsEvent(event: matrixEvent)
: null;
}
Future<StudentAnalyticsEvent?> _getStudentAnalytics(
String studentId, {
bool forcedUpdate = false,
}) async {
try {
if (!isSpace) {
debugger(when: kDebugMode);
throw Exception("calling getStudentAnalyticsLocal on non-space room");
}
StudentAnalyticsEvent? localEvent = _getStudentAnalyticsLocal(studentId);
if (localEvent == null) {
await postLoad();
localEvent = _getStudentAnalyticsLocal(studentId);
}
if (studentId == client.userID && localEvent == null) {
final Event? matrixEvent = await _createStudentAnalyticsEvent();
if (matrixEvent != null) {
localEvent = StudentAnalyticsEvent(event: matrixEvent);
}
}
return localEvent;
} catch (err) {
debugger(when: kDebugMode);
rethrow;
}
}
/// if [studentIds] is null, returns all students
Future<List<StudentAnalyticsEvent?>> _getClassAnalytics([
List<String>? studentIds,
]) async {
await postLoad();
await requestParticipants();
final List<Future<StudentAnalyticsEvent?>> sassFutures = [];
final List<String> filteredIds = students
.where(
(element) => studentIds == null || studentIds.contains(element.id),
)
.map((e) => e.id)
.toList();
for (final id in filteredIds) {
sassFutures.add(
getStudentAnalytics(
id,
),
);
}
return Future.wait(sassFutures);
}
/// if [isSpace]
/// for all child chats, call _getChatAnalyticsGlobal and merge results
/// else
/// get analytics from pangea chat server
/// do any needed conversion work
/// save RoomAnalytics object to PangeaEventTypes.analyticsSummary event
Future<Event?> _createStudentAnalyticsEvent() async {
try {
await postLoad();
if (!pangeaCanSendEvent(PangeaEventTypes.studentAnalyticsSummary)) {
ErrorHandler.logError(
m: "null powerLevels in createStudentAnalytics",
s: StackTrace.current,
);
return null;
}
if (client.userID == null) {
debugger(when: kDebugMode);
throw Exception("null userId in createStudentAnalytics");
}
final String eventId = await client.setRoomStateWithKey(
id,
PangeaEventTypes.studentAnalyticsSummary,
client.userID!,
StudentAnalyticsSummary(
// studentId: client.userID!,
lastUpdated: DateTime.now(),
messages: [],
).toJson(),
);
final Event? event = await getEventById(eventId);
if (event == null) {
debugger(when: kDebugMode);
throw Exception(
"null event after creation with eventId $eventId in createStudentAnalytics",
);
}
return event;
} catch (err, stack) {
ErrorHandler.logError(e: err, s: stack, data: powerLevels);
return null;
}
}
/// for each chat in class
/// get timeline back to january 15
/// get messages
/// discard timeline
/// save messages to StudentAnalyticsSummary
Future<void> _updateMyLearningAnalyticsForClass([
PLocalStore? storageService,
]) async {
try {
final String migratedAnalyticsKey =
"MIGRATED_ANALYTICS_KEY${id.localpart}";
if (storageService?.read(
migratedAnalyticsKey,
local: true,
) ??
false) return;
if (!isPangeaClass && !isExchange) {
throw Exception(
"In updateMyLearningAnalyticsForClass with room that is not not a class",
);
}
if (client.userID == null) {
debugger(when: kDebugMode);
return;
}
final StudentAnalyticsEvent? myAnalEvent =
await getStudentAnalytics(client.userID!);
if (myAnalEvent == null) {
debugPrint("null analytcs event for $id");
if (pangeaCanSendEvent(PangeaEventTypes.studentAnalyticsSummary)) {
// debugger(when: kDebugMode);
}
return;
}
final updateMessages = await _messageListForAllChildChats;
updateMessages.removeWhere(
(element) => myAnalEvent.content.messages.any(
(e) => e.eventId == element.eventId,
),
);
myAnalEvent.bulkUpdate(updateMessages);
await storageService?.save(
migratedAnalyticsKey,
true,
local: true,
);
} catch (err, s) {
if (kDebugMode) rethrow;
// debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: s);
}
}
// invite teachers of 1 space to 1 analytics room
Future<void> _inviteSpaceTeachersToAnalyticsRoom(Room analyticsRoom) async {
if (!isSpace) {
debugPrint(
"inviteSpaceTeachersToAnalyticsRoom called on non-space room",
);
Sentry.addBreadcrumb(
Breadcrumb(
message:
"inviteSpaceTeachersToAnalyticsRoom called on non-space room",
),
);
return;
}
if (!analyticsRoom.participantListComplete) {
await analyticsRoom.requestParticipants();
}
final List<User> participants = analyticsRoom.getParticipants();
for (final User teacher in (await teachers)) {
if (!participants.any((p) => p.id == teacher.id)) {
try {
await analyticsRoom.invite(teacher.id);
} catch (err, s) {
debugPrint(
"Failed to invite teacher ${teacher.id} to analytics room ${analyticsRoom.id}",
);
ErrorHandler.logError(
e: err,
m: "Failed to invite teacher ${teacher.id} to analytics room ${analyticsRoom.id}",
s: s,
);
}
}
}
}
// Invite all teachers to 1 analytics room
// Handles case when students cannot add analytics room to space
// So teacher is still able to get analytics data for this student
Future<void> _inviteTeachersToAnalyticsRoom() async {
if (client.userID == null) {
debugPrint("inviteTeachersToAnalyticsRoom called with null userId");
Sentry.addBreadcrumb(
Breadcrumb(
message: "inviteTeachersToAnalyticsRoom called with null userId",
),
);
return;
}
if (!isAnalyticsRoomOfUser(client.userID!)) {
debugPrint("inviteTeachersToAnalyticsRoom called on non-analytics room");
Sentry.addBreadcrumb(
Breadcrumb(
message: "inviteTeachersToAnalyticsRoom called on non-analytics room",
),
);
return;
}
for (final Room space in (await client.classesAndExchangesImStudyingIn)) {
await space.inviteSpaceTeachersToAnalyticsRoom(this);
}
}
// Invite teachers of 1 space to all users' analytics rooms
Future<void> _inviteSpaceTeachersToAnalyticsRooms() async {
for (final Room analyticsRoom in client.allMyAnalyticsRooms) {
await inviteSpaceTeachersToAnalyticsRoom(analyticsRoom);
}
}
}

148
lib/pangea/extensions/pangea_room_extension/children_and_parents.dart Normal file
View file

@ -0,0 +1,148 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom2 on Room {
//note this only will return rooms that the user has joined or been invited to
List<Room> get _joinedChildren {
if (!isSpace) return [];
return spaceChildren
.where((child) => child.roomId != null)
.map(
(child) => client.getRoomById(child.roomId!),
)
.where((child) => child != null)
.cast<Room>()
.where(
(child) => child.membership == Membership.join,
)
.toList();
}
List<String> get _joinedChildrenRoomIds =>
joinedChildren.map((child) => child.id).toList();
List<SpaceChild> get _childrenAndGrandChildren {
if (!isSpace) return [];
final List<SpaceChild> kids = [];
for (final child in spaceChildren) {
kids.add(child);
if (child.roomId != null) {
final Room? childRoom = client.getRoomById(child.roomId!);
if (childRoom != null && childRoom.isSpace) {
kids.addAll(childRoom.spaceChildren);
}
}
}
return kids.where((element) => element.roomId != null).toList();
}
//this assumes that a user has been invited to all group chats in a space
//it is a janky workaround for determining whether a spacechild is a direct chat
//since the spaceChild object doesn't contain this info. this info is only accessible
//when the user has joined or been invited to the room. direct chats included in
//a space show up in spaceChildren but the user has not been invited to them.
List<String> get _childrenAndGrandChildrenDirectChatIds {
final List<String> nonDirectChatRoomIds = childrenAndGrandChildren
.where((child) => child.roomId != null)
.map((e) => client.getRoomById(e.roomId!))
.where((r) => r != null && !r.isDirectChat)
.map((e) => e!.id)
.toList();
return childrenAndGrandChildren
.where(
(child) =>
child.roomId != null &&
!nonDirectChatRoomIds.contains(child.roomId),
)
.map((e) => e.roomId)
.cast<String>()
.toList();
// return childrenAndGrandChildren
// .where((element) => element.roomId != null)
// .where(
// (child) {
// final room = client.getRoomById(child.roomId!);
// return room == null || room.isDirectChat;
// },
// )
// .map((e) => e.roomId)
// .cast<String>()
// .toList();
}
Future<List<Room>> _getChildRooms() async {
final List<Room> children = [];
for (final child in spaceChildren) {
if (child.roomId == null) continue;
final Room? room = client.getRoomById(child.roomId!);
if (room != null) {
children.add(room);
}
}
return children;
}
Future<void> _joinSpaceChild(String roomID) async {
final Room? child = client.getRoomById(roomID);
if (child == null) {
await client.joinRoom(
roomID,
serverName: spaceChildren
.firstWhereOrNull((child) => child.roomId == roomID)
?.via,
);
if (client.getRoomById(roomID) == null) {
await client.waitForRoomInSync(roomID, join: true);
}
return;
}
if (![Membership.invite, Membership.join].contains(child.membership)) {
final waitForRoom = client.waitForRoomInSync(
roomID,
join: true,
);
await child.join();
await waitForRoom;
}
}
//resolve somehow if multiple rooms have the state?
//check logic
Room? _firstParentWithState(String stateType) {
if (![PangeaEventTypes.classSettings, PangeaEventTypes.rules]
.contains(stateType)) {
return null;
}
for (final parent in pangeaSpaceParents) {
if (parent.getState(stateType) != null) {
return parent;
}
}
for (final parent in pangeaSpaceParents) {
final parentFirstRoom = parent.firstParentWithState(stateType);
if (parentFirstRoom != null) return parentFirstRoom;
}
return null;
}
/// find any parents and return the rooms
List<Room> get _immediateClassParents => pangeaSpaceParents
.where(
(element) => element.isPangeaClass,
)
.toList();
List<Room> get _pangeaSpaceParents => client.rooms
.where(
(r) => r.isSpace,
)
.where(
(space) => space.spaceChildren.any(
(room) => room.roomId == id,
),
)
.toList();
}

129
lib/pangea/extensions/pangea_room_extension/class_and_exchange_settings.dart Normal file
View file

@ -0,0 +1,129 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom3 on Room {
DateTime? get _rulesUpdatedAt {
if (!isSpace) return null;
return pangeaRoomRulesStateEvent?.originServerTs ?? creationTime;
}
String get _classCode {
if (!isSpace) {
for (final Room potentialClassRoom in pangeaSpaceParents) {
if (potentialClassRoom.isPangeaClass) {
return potentialClassRoom.classCode;
}
}
return "Not in a class!";
}
return canonicalAlias.replaceAll(":$domainString", "").replaceAll("#", "");
}
void _checkClass() {
if (!isSpace) {
debugger(when: kDebugMode);
Sentry.addBreadcrumb(
Breadcrumb(message: "calling room.students with non-class room"),
);
}
}
List<User> get _students {
checkClass();
return isSpace
? getParticipants()
.where(
(e) =>
e.powerLevel < ClassDefaultValues.powerLevelOfAdmin &&
e.id != BotName.byEnvironment,
)
.toList()
: getParticipants();
}
Future<List<User>> get _teachers async {
checkClass();
final List<User> participants = await requestParticipants();
return isSpace
? participants
.where(
(e) =>
e.powerLevel == ClassDefaultValues.powerLevelOfAdmin &&
e.id != BotName.byEnvironment,
)
.toList()
: participants;
}
Future<void> _setClassPowerLevels() async {
try {
if (ownPowerLevel < ClassDefaultValues.powerLevelOfAdmin) {
return;
}
final Event? currentPower = getState(EventTypes.RoomPowerLevels);
final Map<String, dynamic>? currentPowerContent =
currentPower?.content["events"] as Map<String, dynamic>?;
final spaceChildPower = currentPowerContent?[EventTypes.spaceChild];
final studentAnalyticsPower =
currentPowerContent?[PangeaEventTypes.studentAnalyticsSummary];
if ((spaceChildPower == null || studentAnalyticsPower == null) &&
currentPowerContent != null) {
currentPowerContent["events"][EventTypes.spaceChild] = 0;
currentPowerContent["events"]
[PangeaEventTypes.studentAnalyticsSummary] = 0;
await client.setRoomStateWithKey(
id,
EventTypes.RoomPowerLevels,
currentPower?.stateKey ?? "",
currentPowerContent,
);
}
} catch (err, s) {
debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: s, data: toJson());
}
}
DateTime? get _classSettingsUpdatedAt {
if (!isSpace) return null;
return languageSettingsStateEvent?.originServerTs ?? creationTime;
}
/// the pangeaClass event is listed an importantStateEvent so, if event exists,
/// it's already local. If it's an old class and doesn't, then the class_controller
/// should automatically migrate during this same session, when the space is first loaded
ClassSettingsModel? get _classSettings {
try {
if (!isSpace) {
return null;
}
final Map<String, dynamic>? content = languageSettingsStateEvent?.content;
if (content != null) {
final ClassSettingsModel classSettings =
ClassSettingsModel.fromJson(content);
return classSettings;
}
return null;
} catch (err, s) {
Sentry.addBreadcrumb(
Breadcrumb(
message: "Error in classSettings",
data: {"room": toJson()},
),
);
ErrorHandler.logError(e: err, s: s);
return null;
}
}
Event? get _languageSettingsStateEvent =>
getState(PangeaEventTypes.classSettings);
Event? get _pangeaRoomRulesStateEvent => getState(PangeaEventTypes.rules);
ClassSettingsModel? get _firstLanguageSettings =>
classSettings ??
firstParentWithState(PangeaEventTypes.classSettings)?.classSettings;
}

323
lib/pangea/extensions/pangea_room_extension/events.dart Normal file
View file

@ -0,0 +1,323 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom4 on Room {
Future<Event?> _sendPangeaEvent({
required Map<String, dynamic> content,
required String parentEventId,
required String type,
}) async {
try {
debugPrint("creating $type child for $parentEventId");
Sentry.addBreadcrumb(Breadcrumb.fromJson(content));
if (parentEventId.contains("web")) {
debugger(when: kDebugMode);
Sentry.addBreadcrumb(
Breadcrumb(
message:
"sendPangeaEvent with likely invalid parentEventId $parentEventId",
),
);
}
final Map<String, dynamic> repContent = {
// what is the functionality of m.reference?
"m.relates_to": {"rel_type": type, "event_id": parentEventId},
type: content,
};
final String? newEventId = await sendEvent(repContent, type: type);
if (newEventId == null) {
debugger(when: kDebugMode);
return null;
}
//PTODO - handle the frequent case of a null newEventId
final Event? newEvent = await getEventById(newEventId);
if (newEvent == null) {
debugger(when: kDebugMode);
}
return newEvent;
} catch (err, stack) {
// debugger(when: kDebugMode);
ErrorHandler.logError(
e: err,
s: stack,
data: {
"type": type,
"parentEventId": parentEventId,
"content": content,
},
);
return null;
}
}
Future<String?> _pangeaSendTextEvent(
String message, {
String? txid,
Event? inReplyTo,
String? editEventId,
bool parseMarkdown = true,
bool parseCommands = false,
String msgtype = MessageTypes.Text,
String? threadRootEventId,
String? threadLastEventId,
PangeaRepresentation? originalSent,
PangeaRepresentation? originalWritten,
PangeaMessageTokens? tokensSent,
PangeaMessageTokens? tokensWritten,
ChoreoRecord? choreo,
UseType? useType,
}) {
// if (parseCommands) {
// return client.parseAndRunCommand(this, message,
// inReplyTo: inReplyTo,
// editEventId: editEventId,
// txid: txid,
// threadRootEventId: threadRootEventId,
// threadLastEventId: threadLastEventId);
// }
final event = <String, dynamic>{
'msgtype': msgtype,
'body': message,
ModelKey.choreoRecord: choreo?.toJson(),
ModelKey.originalSent: originalSent?.toJson(),
ModelKey.originalWritten: originalWritten?.toJson(),
ModelKey.tokensSent: tokensSent?.toJson(),
ModelKey.tokensWritten: tokensWritten?.toJson(),
ModelKey.useType: useType?.string,
};
if (parseMarkdown) {
final html = markdown(
event['body'],
getEmotePacks: () => getImagePacksFlat(ImagePackUsage.emoticon),
getMention: getMention,
);
// if the decoded html is the same as the body, there is no need in sending a formatted message
if (HtmlUnescape().convert(html.replaceAll(RegExp(r'<br />\n?'), '\n')) !=
event['body']) {
event['format'] = 'org.matrix.custom.html';
event['formatted_body'] = html;
}
}
return sendEvent(
event,
txid: txid,
inReplyTo: inReplyTo,
editEventId: editEventId,
threadRootEventId: threadRootEventId,
threadLastEventId: threadLastEventId,
);
}
/// update state event and return eventId
Future<String> _updateStateEvent(Event stateEvent) {
if (stateEvent.stateKey == null) {
throw Exception("stateEvent.stateKey is null");
}
return client.setRoomStateWithKey(
id,
stateEvent.type,
stateEvent.stateKey!,
stateEvent.content,
);
}
Future<List<RecentMessageRecord>> get _messageListForAllChildChats async {
try {
if (!isSpace) return [];
final List<Room> spaceChats = spaceChildren
.where((e) => e.roomId != null)
.map((e) => client.getRoomById(e.roomId!))
.where((element) => element != null)
.cast<Room>()
.where((element) => !element.isSpace)
.toList();
final List<Future<List<RecentMessageRecord>>> msgListFutures = [];
for (final chat in spaceChats) {
msgListFutures.add(chat._messageListForChat);
}
final List<List<RecentMessageRecord>> msgLists =
await Future.wait(msgListFutures);
final List<RecentMessageRecord> joined = [];
for (final msgList in msgLists) {
joined.addAll(msgList);
}
return joined;
} catch (err) {
// debugger(when: kDebugMode);
rethrow;
}
}
Future<List<RecentMessageRecord>> get _messageListForChat async {
try {
int numberOfSearches = 0;
if (isSpace) {
throw Exception(
"In messageListForChat with room that is not a chat",
);
}
final Timeline timeline = await getTimeline();
while (timeline.canRequestHistory && numberOfSearches < 50) {
await timeline.requestHistory(historyCount: 100);
numberOfSearches += 1;
}
if (timeline.canRequestHistory) {
debugger(when: kDebugMode);
}
final List<RecentMessageRecord> msgs = [];
for (final event in timeline.events) {
if (event.senderId == client.userID &&
event.type == EventTypes.Message &&
event.content['msgtype'] == MessageTypes.Text) {
final PangeaMessageEvent pMsgEvent = PangeaMessageEvent(
event: event,
timeline: timeline,
ownMessage: true,
);
msgs.add(
RecentMessageRecord(
eventId: event.eventId,
chatId: id,
useType: pMsgEvent.useType,
time: event.originServerTs,
),
);
}
}
return msgs;
} catch (err, s) {
if (kDebugMode) rethrow;
debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: s);
return [];
}
}
ConstructEvent? _vocabEventLocal(String lemma) {
if (!isAnalyticsRoom) throw Exception("not an analytics room");
final Event? matrixEvent = getState(PangeaEventTypes.vocab, lemma);
return matrixEvent != null ? ConstructEvent(event: matrixEvent) : null;
}
Future<ConstructEvent> _vocabEvent(
String lemma,
ConstructType type, [
bool makeIfNull = false,
]) async {
try {
if (!isAnalyticsRoom) throw Exception("not an analytics room");
ConstructEvent? localEvent = _vocabEventLocal(lemma);
if (localEvent != null) return localEvent;
await postLoad();
localEvent = _vocabEventLocal(lemma);
if (localEvent == null && isRoomOwner && makeIfNull) {
final Event matrixEvent = await _createVocabEvent(lemma, type);
localEvent = ConstructEvent(event: matrixEvent);
}
return localEvent!;
} catch (err) {
debugger(when: kDebugMode);
rethrow;
}
}
Future<List<OneConstructUse>> _removeEditedLemmas(
List<OneConstructUse> lemmaUses,
) async {
final List<String> removeUses = [];
for (final use in lemmaUses) {
if (use.msgId == null) continue;
final List<String> removeIds = await client.getEditHistory(
use.chatId,
use.msgId!,
);
removeUses.addAll(removeIds);
}
lemmaUses.removeWhere((use) => removeUses.contains(use.msgId));
final allEvents = await allConstructEvents;
for (final constructEvent in allEvents) {
await constructEvent.removeEdittedUses(removeUses, client);
}
return lemmaUses;
}
Future<void> _saveConstructUsesSameLemma(
String lemma,
ConstructType type,
List<OneConstructUse> lemmaUses, {
bool isEdit = false,
}) async {
final ConstructEvent? localEvent = _vocabEventLocal(lemma);
if (isEdit) {
lemmaUses = await removeEditedLemmas(lemmaUses);
}
if (localEvent == null) {
await client.setRoomStateWithKey(
id,
PangeaEventTypes.vocab,
lemma,
ConstructUses(lemma: lemma, type: type, uses: lemmaUses).toJson(),
);
} else {
localEvent.addAll(lemmaUses);
await updateStateEvent(localEvent.event);
}
}
Future<List<ConstructEvent>> get _allConstructEvents async {
await postLoad();
return states[PangeaEventTypes.vocab]
?.values
.map((Event event) => ConstructEvent(event: event))
.toList()
.cast<ConstructEvent>() ??
[];
}
Future<Event> _createVocabEvent(String lemma, ConstructType type) async {
try {
if (!isRoomOwner) {
throw Exception(
"Tried to create vocab event in room where user is not owner",
);
}
final String eventId = await client.setRoomStateWithKey(
id,
PangeaEventTypes.vocab,
lemma,
ConstructUses(lemma: lemma, type: type).toJson(),
);
final Event? event = await getEventById(eventId);
if (event == null) {
debugger(when: kDebugMode);
throw Exception(
"null event after creation with eventId $eventId in _createVocabEvent",
);
}
return event;
} catch (err, stack) {
debugger(when: kDebugMode);
ErrorHandler.logError(e: err, s: stack, data: powerLevels);
rethrow;
}
}
}

82
lib/pangea/extensions/pangea_room_extension/room_information.dart Normal file
View file

@ -0,0 +1,82 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom5 on Room {
DateTime? get _creationTime =>
getState(EventTypes.RoomCreate)?.originServerTs;
String? get _creatorId => getState(EventTypes.RoomCreate)?.senderId;
String get _domainString =>
AppConfig.defaultHomeserver.replaceAll("matrix.", "");
bool _isChild(String roomId) =>
isSpace && spaceChildren.any((room) => room.roomId == roomId);
bool _isFirstOrSecondChild(String roomId) {
return isSpace &&
(spaceChildren.any((room) => room.roomId == roomId) ||
spaceChildren
.where((sc) => sc.roomId != null)
.map((sc) => client.getRoomById(sc.roomId!))
.any(
(room) =>
room != null &&
room.isSpace &&
room.spaceChildren.any((room) => room.roomId == roomId),
));
}
bool get _isExchange =>
isSpace &&
languageSettingsStateEvent == null &&
pangeaRoomRulesStateEvent != null;
bool get _isDirectChatWithoutMe =>
isDirectChat && !getParticipants().any((e) => e.id == client.userID);
bool _isMadeForLang(String langCode) {
final creationContent = getState(EventTypes.RoomCreate)?.content;
return creationContent?.tryGet<String>(ModelKey.langCode) == langCode ||
creationContent?.tryGet<String>(ModelKey.oldLangCode) == langCode;
}
Future<bool> get _isBotRoom async {
final List<User> participants = await requestParticipants();
return participants.any(
(User user) => user.id == BotName.byEnvironment,
);
}
Future<bool> get _isBotDM async =>
(await isBotRoom) && getParticipants().length == 2;
bool get _isLocked {
if (isDirectChat) return false;
if (!isSpace) {
if (eventsDefaultPowerLevel == null) return false;
return (eventsDefaultPowerLevel ?? 0) >=
ClassDefaultValues.powerLevelOfAdmin;
}
int joinedRooms = 0;
for (final child in spaceChildren) {
if (child.roomId == null) continue;
final Room? room = client.getRoomById(child.roomId!);
if (room?.isLocked == false) {
return false;
}
if (room != null) {
joinedRooms += 1;
}
}
return joinedRooms > 0 ? true : false;
}
bool get _isPangeaClass => isSpace && languageSettingsStateEvent != null;
bool _isAnalyticsRoomOfUser(String userId) =>
isAnalyticsRoom && isMadeByUser(userId);
bool get _isAnalyticsRoom =>
getState(EventTypes.RoomCreate)?.content.tryGet<String>('type') ==
PangeaRoomTypes.analytics;
}

83
lib/pangea/extensions/pangea_room_extension/room_settings.dart Normal file
View file

@ -0,0 +1,83 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom6 on Room {
PangeaRoomRules? get _pangeaRoomRules {
try {
final Map<String, dynamic>? content = pangeaRoomRulesStateEvent?.content;
if (content != null) {
final PangeaRoomRules roomRules = PangeaRoomRules.fromJson(content);
return roomRules;
}
return null;
} catch (err, s) {
Sentry.addBreadcrumb(
Breadcrumb(
message: "Error in pangeaRoomRules",
data: {"room": toJson()},
),
);
ErrorHandler.logError(e: err, s: s);
return null;
}
}
PangeaRoomRules? get _firstRules =>
pangeaRoomRules ??
firstParentWithState(PangeaEventTypes.rules)?.pangeaRoomRules;
IconData? get _roomTypeIcon {
if (membership == Membership.invite) return Icons.add;
if (isPangeaClass) return Icons.school;
if (isExchange) return Icons.connecting_airports;
if (isAnalyticsRoom) return Icons.analytics;
if (isDirectChat) return Icons.forum;
return Icons.group;
}
Text _nameAndRoomTypeIcon([TextStyle? textStyle]) => Text.rich(
style: textStyle,
TextSpan(
children: [
WidgetSpan(
child: Icon(roomTypeIcon),
),
TextSpan(
text: ' $name',
),
],
),
);
BotOptionsModel? get _botOptions {
if (isSpace) return null;
return BotOptionsModel.fromJson(
getState(PangeaEventTypes.botOptions)?.content ?? {},
);
}
Future<bool> _suggestedInSpace(Room space) async {
try {
final Map<String, dynamic> resp =
await client.getRoomStateWithKey(space.id, EventTypes.spaceChild, id);
return resp.containsKey('suggested') ? resp['suggested'] as bool : true;
} catch (err) {
ErrorHandler.logError(
e: "Failed to fetch suggestion status of room $id in space ${space.id}",
s: StackTrace.current,
);
return true;
}
}
Future<void> _setSuggestedInSpace(bool suggest, Room space) async {
try {
await space.setSpaceChild(id, suggested: suggest);
} catch (err) {
ErrorHandler.logError(
e: "Failed to set suggestion status of room $id in space ${space.id}",
s: StackTrace.current,
);
return;
}
}
}

107
lib/pangea/extensions/pangea_room_extension/user_permissions.dart Normal file
View file

@ -0,0 +1,107 @@
part of "../pangea_room_extension.dart";
extension PangeaRoom7 on Room {
bool _isMadeByUser(String userId) =>
getState(EventTypes.RoomCreate)?.senderId == userId;
//if the user is an admin of the room or any immediate parent of the room
//Question: check parents of parents?
//check logic
bool get _isSpaceAdmin {
if (isSpace) return _isRoomAdmin;
for (final parent in pangeaSpaceParents) {
if (parent._isRoomAdmin) {
return true;
}
}
for (final parent in pangeaSpaceParents) {
for (final parent2 in parent.pangeaSpaceParents) {
if (parent2._isRoomAdmin) {
return true;
}
}
}
return false;
}
bool _isUserRoomAdmin(String userId) => getParticipants().any(
(e) =>
e.id == userId &&
e.powerLevel == ClassDefaultValues.powerLevelOfAdmin,
);
bool _isUserSpaceAdmin(String userId) {
if (isSpace) return isUserRoomAdmin(userId);
for (final parent in pangeaSpaceParents) {
if (parent.isUserRoomAdmin(userId)) {
return true;
}
}
return false;
}
bool get _isRoomOwner =>
getState(EventTypes.RoomCreate)?.senderId == client.userID;
bool get _isRoomAdmin =>
ownPowerLevel == ClassDefaultValues.powerLevelOfAdmin;
bool get _showClassEditOptions => isSpace && isRoomAdmin;
bool get _canDelete => isSpaceAdmin;
bool _canIAddSpaceChild(Room? room) {
if (!isSpace) {
ErrorHandler.logError(
m: "should not call canIAddSpaceChildren on non-space room",
data: toJson(),
s: StackTrace.current,
);
return false;
}
if (room != null && !room._isRoomAdmin) {
return false;
}
if (!pangeaCanSendEvent(EventTypes.spaceChild) && !_isRoomAdmin) {
return false;
}
if (room == null) {
return isRoomAdmin || (pangeaRoomRules?.isCreateRooms ?? false);
}
if (room.isExchange) {
return isRoomAdmin;
}
if (!room.isSpace) {
return pangeaRoomRules?.isCreateRooms ?? false;
}
if (room.isPangeaClass) {
ErrorHandler.logError(
m: "should not call canIAddSpaceChild with class",
data: room.toJson(),
s: StackTrace.current,
);
return false;
}
return false;
}
bool get _canIAddSpaceParents =>
_isRoomAdmin || pangeaCanSendEvent(EventTypes.spaceParent);
//overriding the default canSendEvent to check power levels
bool _pangeaCanSendEvent(String eventType) {
final powerLevelsMap = getState(EventTypes.RoomPowerLevels)?.content;
if (powerLevelsMap == null) return 0 <= ownPowerLevel;
final pl = powerLevelsMap
.tryGetMap<String, dynamic>('events')
?.tryGet<int>(eventType) ??
100;
return ownPowerLevel >= pl;
}
int? get _eventsDefaultPowerLevel => getState(EventTypes.RoomPowerLevels)
?.content
.tryGet<int>('events_default');
}