@stevenkellner/team-conduct-api 1.0.36 → 2.0.1

package/src/functions/invitation/getInvitation.ts

@@ -1,154 +1,117 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation, Person, PersonPrivateProperties, Team } from '../../types';
-import { Firestore } from '../../Firestore';
-import { compactMap, Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import {  Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export class InvitationGetInvitationFunction extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunction.ReturnType> {
+export abstract class InvitationGetInvitationFunctionBase extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunctionReturnType> {
 
     public parametersBuilder = Invitation.Id.builder;
 
-    public returnTypeBuilder = InvitationGetInvitationFunction.ReturnType.builder;
-
-    public async execute(invitationId: Invitation.Id): Promise<InvitationGetInvitationFunction.ReturnType> {
-
-        if (this.userId === null)
-            throw new FunctionsError('unauthenticated', 'User not authenticated');
-
-        const invitationSnapshot = await Firestore.shared.invitation(invitationId).snapshot();
-        if (!invitationSnapshot.exists)
-            throw new FunctionsError('not-found', 'Invitation not found');
-        const invitation = Invitation.builder.build(invitationSnapshot.data);
-
-        const teamSnapshot = await Firestore.shared.team(invitation.teamId).snapshot();
-        if (!teamSnapshot.exists)
-            throw new FunctionsError('not-found', 'Team not found');
-        const team = Team.builder.build(teamSnapshot.data);
-
-        if (invitation.personId !== null)
-            return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, team.name, invitation.personId);
-
-        const personSnapshots = await Firestore.shared.persons(invitation.teamId).documentSnapshots();
-        const persons = compactMap(personSnapshots, personSnapshot => {
-            if (!personSnapshot.exists)
-                return null;
-            const person = Person.builder.build(personSnapshot.data);
-            if (person.signInProperties !== null)
-                return null;
-            return {
-                id: person.id,
-                properties: person.properties
-            };
-        });
-        return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, team.name, persons);
-    }
+    public returnTypeBuilder = InvitationGetInvitationFunctionReturnType.builder;
 }
 
-export namespace InvitationGetInvitationFunction {
+export type PersonIdOrPersons = {
+    personId: Person.Id;
+} | {
+    persons: {
+        id: Person.Id,
+        properties: PersonPrivateProperties,
+    }[];
+};
+
+export namespace PersonIdOrPersons {
 
-    export type PersonIdOrPersons = {
-        personId: Person.Id;
+    export type Flatten = {
+        personId: Person.Id.Flatten,
     } | {
         persons: {
-            id: Person.Id,
-            properties: PersonPrivateProperties,
+            id: Person.Id.Flatten,
+            properties: PersonPrivateProperties.Flatten,
         }[];
     };
+}
 
-    export namespace PersonIdOrPersons {
+export class InvitationGetInvitationFunctionReturnType implements Flattable<InvitationGetInvitationFunctionReturnType.Flatten> {
 
-        export type Flatten = {
-            personId: Person.Id.Flatten,
-        } | {
-            persons: {
-                id: Person.Id.Flatten,
-                properties: PersonPrivateProperties.Flatten,
-            }[];
-        };
-    }
+    private constructor(
+        public teamId: Team.Id,
+        public teamName: string,
+        private personIdOrPersons: PersonIdOrPersons
+    ) {}
 
-    export class ReturnType implements Flattable<ReturnType.Flatten> {
-
-        private constructor(
-            public teamId: Team.Id,
-            public teamName: string,
-            private personIdOrPersons: PersonIdOrPersons
-        ) {}
-
-        public static from(teamId: Team.Id, teamName: string, personId: Person.Id): ReturnType;
-        public static from(teamId: Team.Id, teamName: string, persons: { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType;
-        public static from(teamId: Team.Id, teamName: string, personIdOrPersons: Person.Id | { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType {
-            if (Array.isArray(personIdOrPersons)) {
-                return new ReturnType(teamId, teamName, {
-                    persons: personIdOrPersons
-                });
-            }
-            return new ReturnType(teamId, teamName, {
-                personId: personIdOrPersons
+    public static from(teamId: Team.Id, teamName: string, personId: Person.Id): InvitationGetInvitationFunctionReturnType;
+    public static from(teamId: Team.Id, teamName: string, persons: { id: Person.Id, properties: PersonPrivateProperties }[]): InvitationGetInvitationFunctionReturnType;
+    public static from(teamId: Team.Id, teamName: string, personIdOrPersons: Person.Id | { id: Person.Id, properties: PersonPrivateProperties }[]): InvitationGetInvitationFunctionReturnType {
+        if (Array.isArray(personIdOrPersons)) {
+            return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
+                persons: personIdOrPersons
             });
         }
+        return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
+            personId: personIdOrPersons
+        });
+    }
 
-        public get personId(): Person.Id | null {
-            if (!('personId' in this.personIdOrPersons))
-                return null;
-            return this.personIdOrPersons.personId;
-        }
+    public get personId(): Person.Id | null {
+        if (!('personId' in this.personIdOrPersons))
+            return null;
+        return this.personIdOrPersons.personId;
+    }
 
-        public get persons(): {
-                id: Person.Id,
-                properties: PersonPrivateProperties,
-            }[] | null {
-            if (!('persons' in this.personIdOrPersons))
-                return null;
-            return this.personIdOrPersons.persons;
-        }
+    public get persons(): {
+            id: Person.Id,
+            properties: PersonPrivateProperties,
+        }[] | null {
+        if (!('persons' in this.personIdOrPersons))
+            return null;
+        return this.personIdOrPersons.persons;
+    }
 
-        public get flatten(): ReturnType.Flatten {
-            if ('personId' in this.personIdOrPersons) {
-                return {
-                    teamId: this.teamId.flatten,
-                    teamName: this.teamName,
-                    personId: this.personIdOrPersons.personId.flatten
-                };
-            }
+    public get flatten(): InvitationGetInvitationFunctionReturnType.Flatten {
+        if ('personId' in this.personIdOrPersons) {
             return {
                 teamId: this.teamId.flatten,
                 teamName: this.teamName,
-                persons: this.personIdOrPersons.persons.map(person => ({
-                    id: person.id.flatten,
-                    properties: person.properties.flatten
-                }))
-            }
+                personId: this.personIdOrPersons.personId.flatten
+            };
+        }
+        return {
+            teamId: this.teamId.flatten,
+            teamName: this.teamName,
+            persons: this.personIdOrPersons.persons.map(person => ({
+                id: person.id.flatten,
+                properties: person.properties.flatten
+            }))
         }
     }
+}
 
-    export namespace ReturnType {
+export namespace InvitationGetInvitationFunctionReturnType {
 
-        export type Flatten = {
-            teamId: Team.Id.Flatten,
-            teamName: string
-        } & InvitationGetInvitationFunction.PersonIdOrPersons.Flatten;
+    export type Flatten = {
+        teamId: Team.Id.Flatten,
+        teamName: string
+    } & PersonIdOrPersons.Flatten;
 
-        export class TypeBuilder implements ITypeBuilder<Flatten, ReturnType> {
+    export class TypeBuilder implements ITypeBuilder<Flatten, InvitationGetInvitationFunctionReturnType> {
 
-            public build(value: Flatten): ReturnType {
-                if ('personId' in value) {
-                    return ReturnType.from(
-                        Team.Id.builder.build(value.teamId),
-                        value.teamName,
-                        Person.Id.builder.build(value.personId)
-                    );
-                }
-                return ReturnType.from(
+        public build(value: Flatten): InvitationGetInvitationFunctionReturnType {
+            if ('personId' in value) {
+                return InvitationGetInvitationFunctionReturnType.from(
                     Team.Id.builder.build(value.teamId),
                     value.teamName,
-                    value.persons.map(person => ({
-                        id: Person.Id.builder.build(person.id),
-                        properties: PersonPrivateProperties.builder.build(person.properties)
-                    }))
+                    Person.Id.builder.build(value.personId)
                 );
             }
+            return InvitationGetInvitationFunctionReturnType.from(
+                Team.Id.builder.build(value.teamId),
+                value.teamName,
+                value.persons.map(person => ({
+                    id: Person.Id.builder.build(person.id),
+                    properties: PersonPrivateProperties.builder.build(person.properties)
+                }))
+            );
         }
-
-        export const builder = new TypeBuilder();
     }
+
+    export const builder = new TypeBuilder();
 }

package/src/functions/invitation/invite.ts

@@ -1,32 +1,9 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 
-export class InvitationInviteFunction extends FirebaseFunction<Invitation, Invitation.Id> {
+export abstract class InvitationInviteFunctionBase extends FirebaseFunction<Invitation, Invitation.Id> {
 
     public parametersBuilder = Invitation.builder;
 
     public returnTypeBuilder = Invitation.Id.builder;
-
-    public async execute(invitation: Invitation): Promise<Invitation.Id> {
-
-        await checkAuthentication(this.userId, invitation.teamId, 'team-manager');
-
-        if (invitation.personId !== null) {
-
-            const personSnapshot = await Firestore.shared.person(invitation.teamId, invitation.personId).snapshot();
-            if (!personSnapshot.exists)
-                throw new FunctionsError('not-found', 'Person not found');
-
-            if (personSnapshot.data.signInProperties !== null)
-                throw new FunctionsError('already-exists', 'Person already has an account');
-
-        }
-
-        const invitationId = invitation.createId();
-        await Firestore.shared.invitation(invitationId).set(invitation);
-
-        return invitationId;
-    }
 }

package/src/functions/invitation/register.ts

@@ -1,69 +1,18 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { Person, PersonSignInProperties, Team, User, Invitation } from '../../types';
-import { Firestore } from '../../Firestore';
-import { Flattable, ObjectTypeBuilder, UtcDate } from '@stevenkellner/typescript-common-functionality';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
+import { Person, Team, User } from '../../types';
+import { Flattable, ObjectTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export namespace InvitationRegisterFunction {
+export type InvitationRegisterFunctionParameters = {
+    teamId: Team.Id
+    personId: Person.Id
+};
 
-    export type Parameters = {
-        teamId: Team.Id
-        personId: Person.Id
-    };
-}
-
-export class InvitationRegisterFunction extends FirebaseFunction<InvitationRegisterFunction.Parameters, User> {
+export abstract class InvitationRegisterFunctionBase extends FirebaseFunction<InvitationRegisterFunctionParameters, User> {
 
-    public parametersBuilder =  new ObjectTypeBuilder<Flattable.Flatten<InvitationRegisterFunction.Parameters>, InvitationRegisterFunction.Parameters>({
+    public parametersBuilder =  new ObjectTypeBuilder<Flattable.Flatten<InvitationRegisterFunctionParameters>, InvitationRegisterFunctionParameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder
     });
 
     public returnTypeBuilder = User.builder;
-
-    public async execute(parameters: InvitationRegisterFunction.Parameters): Promise<User> {
-
-        if (this.userId === null)
-            throw new FunctionsError('unauthenticated', 'User not authenticated');
-        const userId = User.Id.builder.build(this.userId);
-        const user = await this.getUser(userId);
-
-        if (user.teams.has(parameters.teamId))
-            throw new FunctionsError('already-exists', 'User already in team');
-
-        const teamSnapshot = await Firestore.shared.team(parameters.teamId).snapshot();
-        if (!teamSnapshot.exists)
-            throw new FunctionsError('not-found', 'Team not found');
-        const team = Team.builder.build(teamSnapshot.data);
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found');
-        const person = Person.builder.build(personSnapshot.data);
-
-        if (person.signInProperties !== null)
-            throw new FunctionsError('already-exists', 'Person already registered');
-
-        await this.removeUserInvitation(parameters.teamId, parameters.personId);
-
-        user.teams.set(parameters.teamId, new User.TeamProperties(team.name, parameters.personId));
-        await Firestore.shared.user(userId).set(user);
-
-        person.signInProperties = new PersonSignInProperties(userId, UtcDate.now);
-        await Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-
-        return user;
-    }
-
-    private async getUser(userId: User.Id): Promise<User> {
-        const userSnapshot = await Firestore.shared.user(userId).snapshot();
-        if (userSnapshot.exists)
-            return User.builder.build(userSnapshot.data);
-        return new User(userId);
-    }
-
-    private async removeUserInvitation(teamId: Team.Id, personId: Person.Id) {
-        const invitation = new Invitation(teamId, personId);
-        const invitationId = invitation.createId();
-        await Firestore.shared.invitation(invitationId).remove();
-    }
 }

package/src/functions/invitation/withdraw.ts

@@ -1,24 +1,10 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export class InvitationWithdrawFunction extends FirebaseFunction<Invitation, void> {
+export abstract class InvitationWithdrawFunctionBase extends FirebaseFunction<Invitation, void> {
 
     public parametersBuilder = Invitation.builder;
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(invitation: Invitation): Promise<void> {
-
-        await checkAuthentication(this.userId, invitation.teamId, 'team-manager');
-
-        const invitationId = invitation.createId();
-        const invitationSnapshot = await Firestore.shared.invitation(invitationId).snapshot();
-        if (!invitationSnapshot.exists)
-            throw new FunctionsError('not-found', 'Invitation not found');
-
-        await Firestore.shared.invitation(invitationId).remove();
-    }
 }

package/src/functions/notification/register.ts

@@ -1,39 +1,20 @@
-import { NotificationProperties } from '../../types/NotificationProperties';
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Firestore } from '../../Firestore';
 
-export namespace NotificationRegisterFunction {
-
-    export type Parameters = {
-        teamId: Team.Id,
-        personId: Person.Id,
-        token: string
-    }
+export type NotificationRegisterFunctionParameters = {
+    teamId: Team.Id,
+    personId: Person.Id,
+    token: string
 }
 
-export class NotificationRegisterFunction extends FirebaseFunction<NotificationRegisterFunction.Parameters, void> {
+export abstract class NotificationRegisterFunctionBase extends FirebaseFunction<NotificationRegisterFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationRegisterFunction.Parameters>, NotificationRegisterFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationRegisterFunctionParameters>, NotificationRegisterFunctionParameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         token: new ValueTypeBuilder()
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: NotificationRegisterFunction.Parameters): Promise<void> {
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found');
-        const person = Person.builder.build(personSnapshot.data);
-
-        if (person.signInProperties === null)
-            throw new FunctionsError('unauthenticated', 'Person not signed in');
-
-        person.signInProperties.notificationProperties.tokens.set(NotificationProperties.TokenId.create(parameters.token), parameters.token);
-        await Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-    }
 }

package/src/functions/notification/subscribe.ts

@@ -1,38 +1,20 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { NotificationProperties, Person, Team } from '../../types';
 import { ArrayTypeBuilder, Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Firestore } from '../../Firestore';
 
-export namespace NotificationSubscribeFunction {
+export type NotificationSubscribeFunctionParameters = {
+    teamId: Team.Id,
+    personId: Person.Id,
+    subscriptions: NotificationProperties.Subscription[]
+};
 
-    export type Parameters = {
-        teamId: Team.Id,
-        personId: Person.Id,
-        subscriptions: NotificationProperties.Subscription[]
-    }
-}
-
-export class NotificationSubscribeFunction extends FirebaseFunction<NotificationSubscribeFunction.Parameters, void> {
+export abstract class NotificationSubscribeFunctionBase extends FirebaseFunction<NotificationSubscribeFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationSubscribeFunction.Parameters>, NotificationSubscribeFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationSubscribeFunctionParameters>, NotificationSubscribeFunctionParameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         subscriptions: new ArrayTypeBuilder(new ValueTypeBuilder())
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: NotificationSubscribeFunction.Parameters): Promise<void> {
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found');
-        const person = Person.builder.build(personSnapshot.data);
-
-        if (person.signInProperties === null)
-            throw new FunctionsError('unauthenticated', 'Person not signed in');
-
-        person.signInProperties.notificationProperties.subscriptions = parameters.subscriptions;
-        await Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-    }
 }

package/src/functions/paypalMe/edit.ts

@@ -1,36 +1,18 @@
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Team } from '../../types';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 
-export namespace PaypalMeEditFunction {
+export type PaypalMeEditFunctionParameters = {
+    teamId: Team.Id;
+    paypalMeLink: string | null;
+};
 
-    export type Parameters = {
-        teamId: Team.Id;
-        paypalMeLink: string | null;
-    };
-}
-
-export class PaypalMeEditFunction extends FirebaseFunction<PaypalMeEditFunction.Parameters, void> {
+export abstract class PaypalMeEditFunctionBase extends FirebaseFunction<PaypalMeEditFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PaypalMeEditFunction.Parameters>, PaypalMeEditFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PaypalMeEditFunctionParameters>, PaypalMeEditFunctionParameters>({
         teamId: Team.Id.builder,
         paypalMeLink: new ValueTypeBuilder()
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: PaypalMeEditFunction.Parameters): Promise<void> {
-
-        await checkAuthentication(this.userId, parameters.teamId, 'team-manager');
-
-        const teamSnapshot = await Firestore.shared.team(parameters.teamId).snapshot();
-        if (!teamSnapshot.exists)
-            throw new FunctionsError('not-found', 'Team not found');
-        const team = Team.builder.build(teamSnapshot.data);
-
-        team.paypalMeLink = parameters.paypalMeLink;
-        await Firestore.shared.team(parameters.teamId).set(team);
-    }
 }

package/src/functions/person/add.ts

@@ -1,36 +1,20 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 
-export namespace PersonAddFunction {
+export type PersonAddFunctionParameters = {
+    teamId: Team.Id
+    id: Person.Id,
+    properties: PersonPrivateProperties
+};
 
-    export type Parameters = {
-        teamId: Team.Id
-        id: Person.Id,
-        properties: PersonPrivateProperties
-    };
-}
-
-export class PersonAddFunction extends FirebaseFunction<PersonAddFunction.Parameters, void> {
+export abstract class PersonAddFunctionBase extends FirebaseFunction<PersonAddFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonAddFunction.Parameters>, PersonAddFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonAddFunctionParameters>, PersonAddFunctionParameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder,
         properties: PersonPrivateProperties.builder
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: PersonAddFunction.Parameters): Promise<void> {
-
-        await checkAuthentication(this.userId, parameters.teamId, 'person-manager');
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.id).snapshot();
-        if (personSnapshot.exists)
-            throw new FunctionsError('already-exists', 'Person already exists');
-
-        await Firestore.shared.person(parameters.teamId, parameters.id).set(new Person(parameters.id, parameters.properties));
-    }
 }

package/src/functions/person/delete.ts

@@ -1,37 +1,18 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 
-export namespace PersonDeleteFunction {
-
-    export type Parameters = {
-        teamId: Team.Id,
-        id: Person.Id
-    }
+export type PersonDeleteFunctionParameters = {
+    teamId: Team.Id,
+    id: Person.Id
 }
 
-export class PersonDeleteFunction extends FirebaseFunction<PersonDeleteFunction.Parameters, void> {
+export abstract class PersonDeleteFunctionBase extends FirebaseFunction<PersonDeleteFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonDeleteFunction.Parameters>, PersonDeleteFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonDeleteFunctionParameters>, PersonDeleteFunctionParameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: PersonDeleteFunction.Parameters): Promise<void> {
-
-        await checkAuthentication(this.userId, parameters.teamId, 'person-manager');
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.id).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found');
-
-        if (personSnapshot.data.signInProperties !== null)
-            throw new FunctionsError('failed-precondition', 'Person is signed in');
-
-        await Firestore.shared.person(parameters.teamId, parameters.id).remove();
-    }
 }

package/src/functions/person/update.ts

@@ -1,37 +1,20 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { checkAuthentication } from '../../checkAuthentication';
-import { Firestore } from '../../Firestore';
 
-export namespace PersonUpdateFunction {
+export type PersonUpdateFunctionParameters = {
+    teamId: Team.Id,
+    id: Person.Id,
+    properties: PersonPrivateProperties
+};
 
-    export type Parameters = {
-        teamId: Team.Id,
-        id: Person.Id,
-        properties: PersonPrivateProperties
-    };
-}
-
-export class PersonUpdateFunction extends FirebaseFunction<PersonUpdateFunction.Parameters, void> {
+export abstract class PersonUpdateFunctionBase extends FirebaseFunction<PersonUpdateFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonUpdateFunction.Parameters>, PersonUpdateFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonUpdateFunctionParameters>, PersonUpdateFunctionParameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder,
         properties: PersonPrivateProperties.builder
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: PersonUpdateFunction.Parameters): Promise<void> {
-
-        await checkAuthentication(this.userId, parameters.teamId, 'person-manager');
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.id).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found');
-        const person = Person.builder.build(personSnapshot.data);
-
-        await Firestore.shared.person(parameters.teamId, parameters.id).set(new Person(parameters.id, parameters.properties, person.fineIds, person.signInProperties));
-    }
 }