functions/api/lib/api_endpoint/calendar_event.dart

+import 'package:api/model/calendar_event.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
+import 'package:lib/lib.dart';
+
+class CalendarEventApiEndpoint extends CheckedDbApiEndpoint<CalendarEvent, CalendarEvent> {
+  final User requestingUser;
+  final Iterable<Team> requestingUserTeams;
+
+  @override
+  Future<bool> Function(CalendarEvent) get createItemAllowed => _createItemAllowed;
+
+  @override
+  Future<bool> Function(CalendarEvent) get getItemAllowed => _getItemAllowed;
+
+  @override
+  Future<bool> Function(CalendarEvent, CalendarEvent) get updateItemAllowed => _updateItemAllowed;
+
+  @override
+  Future<bool> Function(CalendarEvent) get deleteItemAllowed => _deleteItemAllowed;
+
+  CalendarEventApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    required this.requestingUser,
+    required this.requestingUserTeams,
+  });
+
+  Future<bool> _createItemAllowed(CalendarEvent item) {
+    return Future.value(
+      _isUserInTeam(item)
+      && _isUserOwner(item)
+    );
+  }
+
+  Future<bool> _getItemAllowed(CalendarEvent item) {
+    return Future.value(
+      _isUserInTeam(item)
+    );
+  }
+
+  Future<bool> _updateItemAllowed(CalendarEvent item, CalendarEvent originalItem) {
+    return Future.value(
+      item.id == originalItem.id
+      && _isUserInTeam(item)
+      && _isUserOwner(item)
+      && _isUserOwner(originalItem)
+    );
+  }
+
+  Future<bool> _deleteItemAllowed(CalendarEvent item) {
+    return Future.value(
+      _isUserOwner(item)
+    );
+  }
+
+  bool _isUserOwner(CalendarEvent item) {
+    return requestingUser.id == item.userId;
+  }
+
+  bool _isUserInTeam(CalendarEvent item) {
+    return requestingUserTeams.any((team) => team.id == item.teamId);
+  }
+}

functions/api/lib/debt/debt_api_endpoint.dart → functions/api/lib/api_endpoint/debt.dart

-import 'package:api/debt/debt.dart';
-import 'package:api/debt/debt_service.dart';
-import 'package:api/requesting_user/requesting_user_details.dart';
+import 'package:api/model/debt.dart';
+import 'package:api/model/user.dart';
+import 'package:api/service/debt.dart';
 import 'package:lib/lib.dart';
 
 class DebtApiEndpoint extends ApiEndpoint {
-  final RequestingUserDetails requestingUser;
+  final User requestingUser;
   final DebtService debtService;
   final Map<String, dynamic> Function(Debt) itemToResponse;
 
@@ -17,7 +17,7 @@ class DebtApiEndpoint extends ApiEndpoint {
 
   @override
   Future<Map<String, dynamic>> handleGet(context) async {
-    var items = await debtService.getDebt(requestingUser.userId).toList();
+    var items = await debtService.getDebt(requestingUser.id).where((e) => checkGetAllowed(e, requestingUser.id)).toList();
 
     return listResponse(context, items, itemToResponse);
   }
@@ -32,4 +32,7 @@ class DebtApiEndpoint extends ApiEndpoint {
     throw ApiActionForbiddenException("put", "debt");
   }
 
+  bool checkGetAllowed(Debt debt, String userId) {
+    return debt.creditor == userId || debt.debtor == userId;
+  }
 }

functions/api/lib/api_endpoint/payment/driven_distance_distributed.dart

+import 'dart:async';
+
+import 'package:api/model/payment/driven_distance_distributed.dart';
+import 'package:api/model/route.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
+import 'package:lib/lib.dart';
+
+class DrivenDistanceDistributedPaymentApiEndpoint extends CheckedDbApiEndpoint<DrivenDistanceDistributedPayment, DrivenDistanceDistributedPayment> {
+  final User requestingUser;
+  final Iterable<Team> requestingUserTeams;
+  final Future<Route> Function(String) getRouteFromId;
+
+  @override
+  Future<bool> Function(DrivenDistanceDistributedPayment) get createItemAllowed => _createItemAllowed;
+
+  @override
+  Future<bool> Function(DrivenDistanceDistributedPayment) get getItemAllowed => _getItemAllowed;
+
+  @override
+  Future<bool> Function(DrivenDistanceDistributedPayment, DrivenDistanceDistributedPayment) get updateItemAllowed => _updateItemAllowed;
+
+  @override
+  Future<bool> Function(DrivenDistanceDistributedPayment) get deleteItemAllowed => _deleteItemAllowed;
+  
+  DrivenDistanceDistributedPaymentApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    required this.requestingUser,
+    required this.requestingUserTeams,
+    required this.getRouteFromId,
+  });
+
+  Future<bool> _createItemAllowed(DrivenDistanceDistributedPayment item) async {
+    return _isUserOwner(item)
+      && _isUserInTeam(item)
+      && _hasAtLeastOneRoute(item)
+      && await _areRoutesInSameTeam(item)
+      && _isAmountOk(item);
+  }
+
+  Future<bool> _getItemAllowed(DrivenDistanceDistributedPayment item) {
+    return Future.value(
+      _isUserInTeam(item)
+    );
+  }
+
+  Future<bool> _updateItemAllowed(DrivenDistanceDistributedPayment item, DrivenDistanceDistributedPayment originalItem) async {
+    return item.id == originalItem.id
+      && _isUserOwner(item)
+      && _isUserOwner(originalItem)
+      && _isUserInTeam(item)
+      && _hasAtLeastOneRoute(item)
+      && await _areRoutesInSameTeam(item)
+      && _isAmountOk(item);
+  }
+
+  Future<bool> _deleteItemAllowed(DrivenDistanceDistributedPayment item) {
+    return Future.value(
+      _isUserOwner(item)
+    );
+  }
+
+  bool _isUserOwner(DrivenDistanceDistributedPayment item) {
+    return item.paidBy == requestingUser.id;
+  }
+
+  bool _isUserInTeam(DrivenDistanceDistributedPayment item) {
+    return requestingUserTeams.any((e) => e.id == item.id);
+  }
+
+  bool _hasAtLeastOneRoute(DrivenDistanceDistributedPayment item) {
+    return item.routeIds.isNotEmpty;
+  }
+
+  Future<bool> _areRoutesInSameTeam(DrivenDistanceDistributedPayment item) async {
+    if(item.routeIds.isEmpty) {
+      return true;
+    }
+    var routes = Stream.fromFutures(item.routeIds.map((e) => getRouteFromId(e)));
+
+    var teamToBeComparedTo = await routes.first;
+    return routes.every((e) => e.teamId == teamToBeComparedTo.teamId);
+  }
+
+  bool _isAmountOk(DrivenDistanceDistributedPayment item) {
+    return item.amount >= 0;
+  }
+}

functions/api/lib/api_endpoint/payment/equally_distributed.dart

+import 'dart:async';
+
+import 'package:api/model/payment/equally_distributed.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
+import 'package:lib/lib.dart';
+
+class EquallyDistributedApiEndpoint extends CheckedDbApiEndpoint<EquallyDistributedPayment, EquallyDistributedPayment> {
+  final User requestingUser;
+  final Iterable<Team> requestingUserTeams;
+
+  @override
+  Future<bool> Function(EquallyDistributedPayment) get createItemAllowed => _createItemAllowed;
+
+  @override
+  Future<bool> Function(EquallyDistributedPayment) get getItemAllowed => _getItemAllowed;
+
+  @override
+  Future<bool> Function(EquallyDistributedPayment, EquallyDistributedPayment) get updateItemAllowed => _updateItemAllowed;
+
+  @override
+  Future<bool> Function(EquallyDistributedPayment) get deleteItemAllowed => _deleteItemAllowed;
+  
+  EquallyDistributedApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    required this.requestingUser,
+    required this.requestingUserTeams,
+  });
+
+  Future<bool> _createItemAllowed(EquallyDistributedPayment item) {
+    return Future.value(
+      _isUserOwner(item)
+      && _isUserInTeam(item)
+      && _isAmountOk(item)
+    );
+  }
+
+  Future<bool> _getItemAllowed(EquallyDistributedPayment item) {
+    return Future.value(
+      _isUserInTeam(item)
+    );
+  }
+
+  Future<bool> _updateItemAllowed(EquallyDistributedPayment item, EquallyDistributedPayment originalItem) {
+    return Future.value(
+      item.id == originalItem.id
+      && _isUserOwner(item)
+      && _isUserOwner(originalItem)
+      && _isUserInTeam(item)
+      && _isAmountOk(item)
+    );
+  }
+
+  Future<bool> _deleteItemAllowed(EquallyDistributedPayment item) {
+    return Future.value(
+      _isUserOwner(item)
+    );
+  }
+
+  bool _isUserOwner(EquallyDistributedPayment item) {
+    return item.paidBy == requestingUser.id;
+  }
+
+  bool _isUserInTeam(EquallyDistributedPayment item) {
+    return requestingUserTeams.any((team) => team.id == item.teamId);
+  }
+
+  bool _isAmountOk(EquallyDistributedPayment item) {
+    return item.amount >= 0;
+  }
+}

functions/api/lib/api_endpoint/payment/user_to_user.dart

+import 'package:api/model/payment/user_to_user.dart';
+import 'package:api/model/user.dart';
+import 'package:lib/lib.dart';
+
+class UserToUserPaymentApiEndpoint extends CheckedDbApiEndpoint<UserToUserPayment, UserToUserPayment> {
+  final User requestingUser;
+
+  @override
+  Future<bool> Function(UserToUserPayment) get createItemAllowed => _createItemAllowed;
+
+  @override
+  Future<bool> Function(UserToUserPayment) get getItemAllowed => _getItemAllowed;
+
+  @override
+  Future<bool> Function(UserToUserPayment, UserToUserPayment) get updateItemAllowed => _updateItemAllowed;
+
+  @override
+  Future<bool> Function(UserToUserPayment) get deleteItemAllowed => _deleteItemAllowed;
+
+  UserToUserPaymentApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    required this.requestingUser,
+  });
+
+  Future<bool> _createItemAllowed(UserToUserPayment item) {
+    return Future.value(
+      _isUserPayer(item)
+      && _isPayerNotPayee(item)
+      && _isAmountOk(item)
+    );
+  }
+
+  Future<bool> _getItemAllowed(UserToUserPayment item) {
+    return Future.value(
+      _isUserPayer(item)
+      || _isUserPayee(item)
+    );
+  }
+
+  Future<bool> _updateItemAllowed(UserToUserPayment item, UserToUserPayment originalItem) {
+    return Future.value(
+      item.id == originalItem.id
+      && _isUserPayer(item)
+      && _isUserPayer(originalItem)
+      && _isPayerNotPayee(item)
+      && _isAmountOk(item)
+    );
+  }
+
+  Future<bool> _deleteItemAllowed(UserToUserPayment item) {
+    return Future.value(
+      _isUserPayer(item)
+    );
+  }
+
+  bool _isUserPayer(UserToUserPayment item) {
+    return item.paidBy == requestingUser.id;
+  }
+
+  bool _isUserPayee(UserToUserPayment item) {
+    return item.paidTo == requestingUser.id;
+  }
+
+  bool _isPayerNotPayee(UserToUserPayment item) {
+    return item.paidBy != item.paidTo;
+  }
+
+  bool _isAmountOk(UserToUserPayment item) {
+    return item.amount >= 0;
+  }
+}

functions/api/lib/point/point_api_endpoint.dart → functions/api/lib/api_endpoint/point.dart

 import 'package:lib/lib.dart';
-import 'package:api/point/point.dart';
+import 'package:api/model/point.dart';
 
 class PointApiEndpoint extends DbApiEndpoint<Point, Point> {
-  PointApiEndpoint({required super.database, required super.itemFromRequest, required super.itemToResponse});
+  PointApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+  });
 
   @override
   Stream<Point> getAll() {
@@ -10,12 +14,12 @@ class PointApiEndpoint extends DbApiEndpoint<Point, Point> {
   }
 
   @override
-  Future<Map<String, dynamic>> handleDelete(context) {
+  Future<Point> delete(String id) {
     throw ApiActionForbiddenException("delete", "point");
   }
 
   @override
-  Future<Map<String, dynamic>> handlePut(context) {
+  Future<Point> update(Point item) {
     throw ApiActionForbiddenException("put", "point");
   }
 }

functions/api/lib/api_endpoint/route.dart

+import 'package:api/model/route.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
+import 'package:lib/lib.dart';
+
+class RouteApiEndpoint extends CheckedDbApiEndpoint<Route, Route> {
+  final User requestingUser;
+  final Iterable<Team> requestingUserTeams;
+
+  @override
+  Future<bool> Function(Route) get createItemAllowed => _createItemAllowed;
+
+  @override
+  Future<bool> Function(Route) get getItemAllowed => _getItemAllowed;
+
+  @override
+  Future<bool> Function(Route, Route) get updateItemAllowed => _updateItemAllowed;
+
+  @override
+  Future<bool> Function(Route) get deleteItemAllowed => _deleteItemAllowed;
+
+  RouteApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    required this.requestingUser,
+    required this.requestingUserTeams,
+  });
+
+  Future<bool> _createItemAllowed(Route item) {
+    return Future.value(
+      _isUserInTeam(item)
+      && _isUserOwner(item)
+    );
+  }
+
+  Future<bool> _getItemAllowed(Route item) {
+    return Future.value(
+      _isUserOwner(item)
+    );
+  }
+
+  Future<bool> _updateItemAllowed(Route item, Route originalItem) {
+    return Future.value(
+      item.id == originalItem.id
+      && _isUserInTeam(item)
+      && _isUserOwner(item)
+      && _isUserOwner(originalItem)
+    );
+  }
+
+  Future<bool> _deleteItemAllowed(Route item) {
+    return Future.value(
+      _isUserOwner(item)
+    );
+  }
+
+  bool _isUserInTeam(Route item) {
+    return item.teamId != null ? requestingUserTeams.any((e) => e.id == item.teamId) : true;
+  }
+
+  bool _isUserOwner(Route item) {
+    return item.userId == requestingUser.id;
+  }
+}

functions/api/lib/schedule/schedule_api_endpoint.dart → functions/api/lib/api_endpoint/schedule.dart

@@ -19,10 +19,11 @@ class ScheduleApiEndpoint extends ApiEndpoint {
 
   @override
   Future<Map<String, dynamic>> handlePost(context) async {
-    if(trigger == "schedule") {
-      return context.res.send(DateTime.now().toIso8601String());
+    if(trigger != "schedule") {
+      throw ApiActionForbiddenException("POST", path);
     }
-    throw ApiActionForbiddenException("POST", path);
+    
+    return context.res.send(DateTime.now().toIso8601String());
   }
 
   @override

functions/api/lib/team/team_api_endpoint.dart → functions/api/lib/api_endpoint/team.dart

-import 'package:api/requesting_user/requesting_user_details.dart';
-import 'package:api/team/team.dart';
-import 'package:api/team/team_service.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
 import 'package:lib/lib.dart';
 
 class TeamApiEndpoint extends ApiEndpoint {
-  final TeamService teamService;
+  final User requestingUser;
+  final Stream<Team> Function(User) getTeamsOfUser;
   final Map<String, dynamic> Function(Team) itemToResponse;
-  final RequestingUserDetails requestingUser;
 
-  TeamApiEndpoint({required this.teamService, required this.itemToResponse, required this.requestingUser});
+  TeamApiEndpoint({required this.requestingUser, required this.getTeamsOfUser, required this.itemToResponse});
 
   @override
   Future<Map<String, dynamic>> handleDelete(context) {
@@ -17,7 +16,7 @@ class TeamApiEndpoint extends ApiEndpoint {
 
   @override
   Future<Map<String, dynamic>> handleGet(context) async {
-    var requestingUserTeams = await teamService.getTeamsOfUser(requestingUser.userId).toList();
+    var requestingUserTeams = await getTeamsOfUser(requestingUser).toList();
 
     return listResponse(context, requestingUserTeams, itemToResponse);
   }

functions/api/lib/user/user_api_endpoint.dart → functions/api/lib/api_endpoint/user.dart

 import 'dart:convert';
 
-import 'package:api/requesting_user/requesting_user_details.dart';
-import 'package:api/team/team_service.dart';
-import 'package:api/user/user.dart';
+import 'package:api/model/team.dart';
+import 'package:api/model/user.dart';
 import 'package:lib/lib.dart';
-import 'package:api/user/user_service.dart';
 
 class UserApiEndpoint extends ApiEndpoint {
-  final UserService userService;
-  final TeamService teamService;
-  final RequestingUserDetails requestingUser;
+  final User requestingUser;
+  final Future<User> Function(String) getUserFromId;
+  final Stream<Team> Function(User) getTeamsOfUser;
   final Map<String, dynamic> Function(User) itemToResponse;
 
-  UserApiEndpoint({required this.userService, required this.teamService, required this.requestingUser, required this.itemToResponse});
+  UserApiEndpoint({required this.requestingUser, required this.getUserFromId, required this.getTeamsOfUser, required this.itemToResponse});
 
   @override
   Future<Map<String, dynamic>> handleDelete(context) {
@@ -23,10 +21,11 @@ class UserApiEndpoint extends ApiEndpoint {
   Future<Map<String, dynamic>> handleGet(context) async {
     var requestedUserId = userIdFromContext(context);
 
-    var requestedUser = await userService.getUser(requestedUserId);
-    var requestedUserTeamIds = await teamService.getTeamsOfUser(requestedUserId).map((team) => team.teamId).toList();
+    var requestedUser = await getUserFromId(requestedUserId);
+    var requestedUserTeamIds = await getTeamsOfUser(requestedUser).map((e) => e.id).toList();
+    var requestingUserTeamIds = await getTeamsOfUser(requestingUser).map((e) => e.id).toList();
 
-    if(!requestingUser.teamIds.any((teamId) => requestedUserTeamIds.contains(teamId))) {
+    if(!requestedUserTeamIds.any((e) => requestingUserTeamIds.contains(e))) {
       throw UnauthorizedException();
     }
 

functions/api/lib/calendar_event/calendar_event_api_endpoint.dart

-import 'package:api/requesting_user/requesting_user_details.dart';
-import 'package:lib/lib.dart';
-import 'package:api/calendar_event/calendar_event.dart';
-
-class CalendarEventApiEndpoint extends DbApiEndpoint<CalendarEvent, CalendarEvent> {
-  final RequestingUserDetails requestingUser;
-
-  CalendarEventApiEndpoint({
-    required super.database,
-    required super.itemFromRequest,
-    required super.itemToResponse,
-    required this.requestingUser,
-  });
-
-  @override
-  Future<CalendarEvent> create(CalendarEvent item) {
-    if (!requestingUser.teamIds.contains(item.teamId)){
-      throw UnauthorizedException();
-    }
-
-    if (requestingUser.userId != item.userId) {
-      throw UnauthorizedException();
-    }
-
-    return super.create(item);
-  }
-
-  @override
-  Future<CalendarEvent> getFromId(String id) async {
-    var item = await super.getFromId(id);
-
-    if(requestingUser.userId != item.userId) {
-      throw UnauthorizedException();
-    }
-
-    return item;
-  }
-
-  @override
-  Stream<CalendarEvent> getFromQueries(Iterable<String> queries) async* {
-    await for(var queryResult in super.getFromQueries(queries)) {
-      if (requestingUser.userId == queryResult.userId) {
-        yield queryResult;
-      }
-    }
-  }
-
-  @override
-  Stream<CalendarEvent> getAll() async* {
-    await for(var item in super.getAll()) {
-      if(requestingUser.userId == item.userId) {
-        yield item;
-      }
-    }
-  }
-
-  @override
-  Future<CalendarEvent> update(CalendarEvent 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/converter/calendar_event/db_converter.dart

 import 'package:lib/lib.dart';
-import 'package:api/calendar_event/calendar_event.dart';
+import 'package:api/model/calendar_event.dart';
 
 extension CalendarEventDbConverter on CalendarEvent {
   static const userIdDbFieldName = "userId";

functions/api/lib/converter/calendar_event/request_response_converter.dart

 import 'package:lib/lib.dart';
-import 'package:api/calendar_event/calendar_event.dart';
+import 'package:api/model/calendar_event.dart';
 
 extension CalendarEventRequestResponseConverter on CalendarEvent {
   static const userIdRequestResponseFieldName = "userId";

functions/api/lib/converter/debt/request_response_converter.dart

-import 'package:api/debt/debt.dart';
+import 'package:api/model/debt.dart';
 
 extension DebtRequestResponseConverter on Debt {
   static const String creditorRequestResponseFieldName = "creditor";

functions/api/lib/converter/payment/db_converter.dart

-import 'package:api/payment/model/payment.dart';
+import 'package:api/model/payment/payment.dart';
 
 extension PaymentDbConverter on Payment {
   static const String amountDbFieldName = "amount";

functions/api/lib/converter/payment/driven_distance_distributed/db_converter.dart

 import 'package:api/converter/payment/team_payment.dart/db_converter.dart';
 import 'package:api/converter/route/db_converter.dart';
-import 'package:api/payment/model/team_payment.dart';
-import 'package:api/payment/model/driven_distance_distributed_payment.dart';
+import 'package:api/model/payment/team.dart';
+import 'package:api/model/payment/driven_distance_distributed.dart';
 import 'package:lib/lib.dart';
 
 extension DrivenDistanceDistributedPaymentDbConverter on DrivenDistanceDistributedPayment {

functions/api/lib/converter/payment/driven_distance_distributed/request_response_converter.dart

 import 'package:api/converter/payment/team_payment.dart/request_response_converter.dart';
-import 'package:api/payment/model/driven_distance_distributed_payment.dart';
-import 'package:api/payment/model/team_payment.dart';
+import 'package:api/model/payment/driven_distance_distributed.dart';
+import 'package:api/model/payment/team.dart';
 import 'package:lib/lib.dart';
 
 extension DrivenDistanceDistributedPaymentRequestResponseConverter on DrivenDistanceDistributedPayment {

functions/api/lib/converter/payment/equally_distributed_payment/db_converter.dart

 import 'package:api/converter/payment/team_payment.dart/db_converter.dart';
-import 'package:api/payment/model/equally_distributed_payment.dart';
-import 'package:api/payment/model/team_payment.dart';
+import 'package:api/model/payment/equally_distributed.dart';
+import 'package:api/model/payment/team.dart';
 import 'package:lib/lib.dart';
 
 extension EquallyDistributedPaymentDbConverter on EquallyDistributedPayment {
@@ -20,7 +20,7 @@ extension EquallyDistributedPaymentDbConverter on EquallyDistributedPayment {
       id: teamPayment.id,
       amount: teamPayment.amount,
       teamId: teamPayment.teamId,
-      timeAdded: teamPayment.createdAt,
+      createdAt: teamPayment.createdAt,
       paidBy: teamPayment.paidBy,
     );
   }

functions/api/lib/converter/payment/equally_distributed_payment/request_response_converter.dart

 import 'package:api/converter/payment/team_payment.dart/request_response_converter.dart';
-import 'package:api/payment/model/equally_distributed_payment.dart';
-import 'package:api/payment/model/team_payment.dart';
+import 'package:api/model/payment/equally_distributed.dart';
+import 'package:api/model/payment/team.dart';
 
 extension EquallyDistributedPaymentRequestResponseConverter on EquallyDistributedPayment {
   Map<String, dynamic> toResponseData() {
     return (this as TeamPayment).toResponseData();
   }
 
-  static EquallyDistributedPayment fromResponse(Map<String, dynamic> map) {
+  static EquallyDistributedPayment fromRequest(Map<String, dynamic> map) {
     var teamPayment = TeamPaymentRequestResponseConverter.fromRequest(map);
     return EquallyDistributedPayment(
       id: teamPayment.id,
       amount: teamPayment.amount,
       teamId: teamPayment.teamId,
-      timeAdded: teamPayment.createdAt,
+      createdAt: teamPayment.createdAt,
       paidBy: teamPayment.paidBy,
     );
   }

functions/api/lib/converter/payment/request_response_converter.dart

-import 'package:api/payment/model/payment.dart';
+import 'package:api/model/payment/payment.dart';
 import 'package:lib/lib.dart';
 
 extension PaymentRequestResponseConverter on Payment {
   static const String amountRequestResponseFieldName = "amount";
   static const String paidByRequestResponseFieldName = "paidBy";
-  static const String timeAddedRequestResponseFieldName = "timeAdded";
+  static const String createdAtRequestResponseFieldName = "timeAdded";
 
   Map<String, dynamic> toResponseData() {
     return {
       RequestResponseVariables.idFieldName: id,
       amountRequestResponseFieldName: amount,
       paidByRequestResponseFieldName: paidBy,
-      timeAddedRequestResponseFieldName: createdAt.toIso8601String(),
+      createdAtRequestResponseFieldName: createdAt.toIso8601String(),
     };
   }
 }