functions/api/lib/payment/model/driven_distance_distributed_payment.dart → functions/api/lib/model/payment/driven_distance_distributed.dart

-import 'package:api/payment/model/team_payment.dart';
+import 'package:api/model/payment/team.dart';
 
 class DrivenDistanceDistributedPayment extends TeamPayment {
   final Iterable<String> routeIds;

functions/api/lib/payment/model/equally_distributed_payment.dart → functions/api/lib/model/payment/equally_distributed.dart

-import 'package:api/payment/model/team_payment.dart';
+import 'package:api/model/payment/team.dart';
 
 class EquallyDistributedPayment extends TeamPayment {
   EquallyDistributedPayment({super.id, required super.amount, required super.teamId, required super.createdAt, required super.paidBy});

functions/api/lib/payment/model/team_payment.dart → functions/api/lib/model/payment/team.dart

-import 'package:api/payment/model/payment.dart';
+import 'package:api/model/payment/payment.dart';
 import 'package:lib/lib.dart';
 
 class TeamPayment extends Payment {

functions/api/lib/payment/model/user_to_user_payment.dart → functions/api/lib/model/payment/user_to_user.dart

-import 'package:api/payment/model/payment.dart';
+import 'package:api/model/payment/payment.dart';
 import 'package:lib/lib.dart';
 
 class UserToUserPayment extends Payment {

functions/api/lib/route/route.dart → functions/api/lib/model/route.dart

 import 'package:lib/lib.dart';
-import 'package:api/point/point.dart';
+import 'package:api/model/point.dart';
 
 class Route implements DbModel {
   final List<Point> points;

functions/api/lib/model/team.dart

+class Team {
+  final String id;
+  final String name;
+
+  Team({required this.id, required this.name});
+}

functions/api/lib/user/user.dart → 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/requesting_user/requesting_user_details.dart

-class RequestingUserDetails {
-  final String userId;
-  final Iterable<String> teamIds;
-
-  RequestingUserDetails({required this.userId, required this.teamIds});
-}

functions/api/lib/route/route_api_endpoint.dart

-import 'package:api/requesting_user/requesting_user_details.dart';
-import 'package:lib/lib.dart';
-import 'package:api/route/route.dart';
-
-class RouteApiEndpoint extends DbApiEndpoint<Route, Route> {
-  final RequestingUserDetails requestingUser;
-  RouteApiEndpoint({required super.database, required super.itemFromRequest, required super.itemToResponse, required this.requestingUser});
-
-  @override
-  Future<Route> create(Route item) {
-    if (!requestingUser.teamIds.contains(item.teamId)){
-      throw UnauthorizedException();
-    }
-
-    if (requestingUser.userId != item.userId) {
-      throw UnauthorizedException();
-    }
-
-    return super.create(item);
-  }
-
-  @override
-  Future<Route> getFromId(String id) async {
-    var item = await super.getFromId(id);
-
-    if(requestingUser.userId != item.userId) {
-      throw UnauthorizedException();
-    }
-
-    return item;
-  }
-
-  @override
-  Stream<Route> getFromQueries(Iterable<String> queries) async* {
-    await for(var queryResult in super.getFromQueries(queries)) {
-      if (requestingUser.userId == queryResult.userId) {
-        yield queryResult;
-      }
-    }
-  }
-
-  @override
-  Stream<Route> getAll() async* {
-    await for(var item in super.getAll()) {
-      if(requestingUser.userId == item.userId) {
-        yield item;
-      }
-    }
-  }
-
-  @override
-  Future<Route> update(Route item) async {
-    var routeId = item.id;
-    if (routeId == null) {
-      throw RequiredArgumentMissing(RequestResponseVariables.idFieldName);
-    }
-    
-    if (requestingUser.userId != item.userId) {
-      throw UnauthorizedException();
-    }
-
-    var dbItem = await getFromId(item.id!);
-    if (requestingUser.userId != dbItem.userId) {
-      throw UnauthorizedException();
-    }
-
-    return super.update(item);
-  }
-}

functions/api/lib/debt/debt_service.dart → functions/api/lib/service/debt.dart

-import 'package:api/debt/debt.dart';
-import 'package:api/payment/model/driven_distance_distributed_payment.dart';
-import 'package:api/payment/model/equally_distributed_payment.dart';
-import 'package:api/payment/model/user_to_user_payment.dart';
-import 'package:api/route/distance_calculator.dart';
-import 'package:api/route/route.dart';
-import 'package:api/team/team.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';
 
 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/route/distance_calculator.dart → functions/api/lib/service/distance_calculator.dart

 import 'package:latlong2/latlong.dart' as latlong;
-import 'package:api/route/route.dart';
+import 'package:api/model/route.dart';
+
+// TODO: as service
 
 extension Distance on Route {
   double get distance {

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/team.dart';
+import 'package:dart_appwrite/dart_appwrite.dart';
+import 'package:lib/lib.dart';
+
+class TeamService extends ClientFunction {
+  late final Teams _teams;
+
+  TeamService({required super.host, required super.projectId, required super.apiKey}) {
+    _teams = Teams(client);
+  }
+
+  Future<Team> getTeam(String teamId) async {
+    var team = await _teams.get(teamId: teamId);
+
+    return Team(
+      id: team.$id,
+      name: team.name
+    );
+  }
+}

functions/api/lib/user/user_service.dart → functions/api/lib/service/user_service.dart

 import 'package:dart_appwrite/dart_appwrite.dart';
 import 'package:lib/lib.dart';
-import 'package:api/user/user.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
     );
   }
 }

functions/api/lib/team/appwrite_user.dart

-class AppwriteUser {
-  final String id;
-  final String email;
-  final String name;
-  final bool isEnabled;
-
-  AppwriteUser({required this.id, required this.email, required this.name, required this.isEnabled});
-}

functions/api/lib/team/membership.dart

-import 'package:api/team/appwrite_user.dart';
-
-class Membership {
-  final AppwriteUser user;
-  final DateTime joinedAt;
-
-  Membership({required this.user, required this.joinedAt});
-}

functions/api/lib/team/team.dart

-import 'package:api/team/membership.dart';
-
-class Team {
-  final String teamId;
-  final String teamName;
-  final Iterable<Membership> memberships;
-
-  Team({required this.teamId, required this.teamName, required this.memberships});
-}