functions/api/lib/model/user.dart

@@ -2,6 +2,7 @@ class User {
   final String id;
   final String email;
   final String name;
+  final bool isEnabled;
 
-  User({required this.id, required this.email, required this.name});
+  User({required this.id, required this.email, required this.name, required this.isEnabled});
 }

functions/api/lib/service/debt.dart

 import 'package:api/model/debt.dart';
+import 'package:api/model/membership.dart';
 import 'package:api/model/payment/driven_distance_distributed.dart';
 import 'package:api/model/payment/equally_distributed.dart';
 import 'package:api/model/payment/user_to_user.dart';
 import 'package:api/service/distance_calculator.dart';
 import 'package:api/model/route.dart';
-import 'package:api/model/team.dart';
 
 class DebtService {
-  final Future<Team> Function(String) getTeamById;
+  final Stream<Membership> Function(String) getMembershipsByTeamId;
   final Future<Route> Function(String) getRouteById;
   final Stream<UserToUserPayment> Function(String) getUserToUserPayments;
   final Stream<EquallyDistributedPayment> Function(String) getEquallyDistributedPayments;
   final Stream<DrivenDistanceDistributedPayment> Function(String) getDrivenDistanceDistributedPayments;
 
   DebtService({
-    required this.getTeamById,
+    required this.getMembershipsByTeamId,
     required this.getRouteById,
     required this.getUserToUserPayments,
     required this.getEquallyDistributedPayments,
@@ -40,8 +40,8 @@ class DebtService {
   }
 
   Stream<Debt> calculateEquallyDistributedPaymentDebt(EquallyDistributedPayment payment) async* {
-    var team = await getTeamById(payment.teamId);
-    var teamMemberIds = team.memberships.where((element) => element.joinedAt.compareTo(payment.createdAt) <= 0).map((e) => e.user.id);
+    var teamMemberships = getMembershipsByTeamId(payment.teamId);
+    var teamMemberIds = await teamMemberships.where((element) => element.joinedAt.compareTo(payment.createdAt) <= 0).map((e) => e.user.id).toList();
 
     var debtAmountPerUser = payment.amount / teamMemberIds.length;
 

functions/api/lib/service/membership_service.dart

+import 'dart:async';
+
+import 'package:api/model/membership.dart';
+import 'package:api/service/team_service.dart';
+import 'package:api/service/user_service.dart';
+import 'package:dart_appwrite/dart_appwrite.dart';
+import 'package:lib/lib.dart';
+
+class MembershipService extends ClientFunction {
+  final UserService userService;
+  final TeamService teamService;
+
+  late final Users _users;
+  late final Teams _teams;
+
+  MembershipService({required super.host, required super.projectId, required super.apiKey, required this.userService, required this.teamService}) {
+    _users = Users(client);
+    _teams = Teams(client);
+  }
+
+  Stream<Membership> getUserMemberships(String userId) async* {
+    var user = await userService.getUser(userId);
+    var memberships = (await _users.listMemberships(userId: user.id)).memberships;
+
+    for (var membership in memberships) {
+      yield Membership(
+        joinedAt: DateTime.parse(membership.joined),
+        team: await teamService.getTeam(membership.teamId),
+        user: user,
+      );
+    }
+  }
+
+  Stream<Membership> getTeamMemberships(String teamId) async* {
+    var team = await teamService.getTeam(teamId);
+    var memberships = (await _teams.listMemberships(teamId: team.id)).memberships;
+
+    for (var membership in memberships) {
+      yield Membership(
+        joinedAt: DateTime.parse(membership.joined),
+        team: team,
+        user: await userService.getUser(membership.userId),
+      );
+    }
+  }
+}

functions/api/lib/service/team_service.dart

 import 'dart:async';
 
-import 'package:api/model/appwrite_user.dart';
-import 'package:api/model/membership.dart';
 import 'package:api/model/team.dart';
 import 'package:dart_appwrite/dart_appwrite.dart';
 import 'package:lib/lib.dart';
 
 class TeamService extends ClientFunction {
   late final Teams _teams;
-  late final Users _users;
 
   TeamService({required super.host, required super.projectId, required super.apiKey}) {
     _teams = Teams(client);
-    _users = Users(client);
-  }
-
-  Stream<Team> getTeamsOfUser(String userId) async* {
-    var memberships = (await _users.listMemberships(userId: userId)).memberships;
-
-    for (var membership in memberships) {
-      yield await getTeam(membership.teamId);
-    }
   }
 
   Future<Team> getTeam(String teamId) async {
     var team = await _teams.get(teamId: teamId);
-    var teamMemberships = (await _teams.listMemberships(teamId: team.$id)).memberships;
 
     return Team(
-      teamId: team.$id,
-      teamName: team.name,
-      memberships: await Stream.fromFutures(teamMemberships.map((e) async => Membership(
-        joinedAt: DateTime.parse(e.joined),
-        user: await _getAppwriteUser(e.userId),
-      ))).toList(),
-    );
-  }
-
-  Future<AppwriteUser> _getAppwriteUser(String userId) async {
-    var user = await _users.get(userId: userId);
-    
-    return AppwriteUser(
-      id: user.$id,
-      email: user.email,
-      name: user.name,
-      isEnabled: user.status,
+      id: team.$id,
+      name: team.name
     );
   }
 }

functions/api/lib/service/user_service.dart

@@ -3,18 +3,20 @@ import 'package:lib/lib.dart';
 import 'package:api/model/user.dart';
 
 class UserService extends ClientFunction {
-  late final Users users;
+  late final Users _users;
 
   UserService({required super.host, required super.projectId, required super.apiKey}) {
-    users = Users(client);
+    _users = Users(client);
   }
 
   Future<User> getUser(String userId) async {
-    var user = await users.get(userId: userId);
+    var user = await _users.get(userId: userId);
+    
     return User(
       id: user.$id,
       email: user.email,
       name: user.name,
+      isEnabled: user.status
     );
   }
 }

lib/lib/lib.dart

@@ -18,3 +18,4 @@ export 'src/interface/api_endpoint.dart';
 export 'src/db_api_endpoint.dart';
 export 'src/exceptions/db_action_forbidden.dart';
 export 'src/converter/list_response/list_to_response_converter.dart';
+export 'src/checked_db_api_endpoint.dart';

lib/lib/src/checked_db_api_endpoint.dart

+import 'package:lib/src/db_api_endpoint.dart';
+import 'package:lib/src/exceptions/id_null.dart';
+import 'package:lib/src/exceptions/unauthorized.dart';
+import 'package:lib/src/interface/db_model.dart';
+
+class CheckedDbApiEndpoint<T extends DbModel, T1> extends DbApiEndpoint<T, T1> {
+  final Future<bool> Function(T)? createItemAllowed;
+  final Future<bool> Function(T1)? getItemAllowed;
+  final Future<bool> Function(T, T1)? updateItemAllowed;
+  final Future<bool> Function(T1)? deleteItemAllowed;
+  final bool allowActionsPerDefault;
+
+  CheckedDbApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    this.createItemAllowed,
+    this.getItemAllowed,
+    this.updateItemAllowed,
+    this.deleteItemAllowed,
+    this.allowActionsPerDefault = false,
+  });
+
+  @override
+  Future<T1> create(T item) async {
+    await checkAndThrowIfNecessary(createItemAllowed, item);
+    return super.create(item);
+  }
+
+  @override
+  Future<T1> update(T item) async {
+    if(item.id == null) {
+      throw IdNullException(item);
+    }
+
+    var originalItem = await super.getFromId(item.id!);
+    await checkAndThrowIfNecessary(updateCheck(item, originalItem), item);
+
+    return super.update(item);
+  }
+
+  @override
+  Future<T1> delete(String id) async {
+    var item = await super.getFromId(id);
+    await checkAndThrowIfNecessary(deleteItemAllowed, item);
+
+    return super.delete(id);
+  }
+
+  @override
+  Future<T1> getFromId(String id) async {
+    var item = await super.getFromId(id);
+    await checkAndThrowIfNecessary(getItemAllowed, item);
+
+    return item;
+  }
+
+  @override
+  Stream<T1> getFromQueries(Iterable<String> queries) async* {
+    await for (var item in super.getFromQueries(queries)) {
+      if(await checkIfAllowed(getItemAllowed, item)) {
+        yield item;
+      }
+    }
+  }
+
+  @override
+  Stream<T1> getAll() async* {
+    await for (var item in super.getAll()) {
+      if(await checkIfAllowed(getItemAllowed, item)) {
+        yield item;
+      }
+    }
+  }
+
+  Future<void> checkAndThrowIfNecessary<T2>(Future<bool> Function(T2)? check, T2 item) async {
+    if(!await checkIfAllowed(check, item)) {
+      throw UnauthorizedException();
+    }
+  }
+
+  Future<bool> checkIfAllowed<T2>(Future<bool> Function(T2)? check, T2 item) {
+    if(check != null) {
+      return check(item);
+    }
+
+    return Future.value(allowActionsPerDefault);
+  }
+
+  Future<bool> Function(T)? updateCheck(T item, T1 originalItem) {
+    if(updateItemAllowed != null) {
+      return (item) => updateItemAllowed!(item, originalItem);
+    }
+    return null;
+  }
+}