@stevenkellner/team-conduct-api 1.0.35 → 2.0.1

package/lib/src/functions/invitation/getInvitation.d.ts

@@ -1,53 +1,52 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation, Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare class InvitationGetInvitationFunction extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunction.ReturnType> {
+export declare abstract class InvitationGetInvitationFunctionBase extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunctionReturnType> {
     parametersBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "invitation">;
-    returnTypeBuilder: InvitationGetInvitationFunction.ReturnType.TypeBuilder;
-    execute(invitationId: Invitation.Id): Promise<InvitationGetInvitationFunction.ReturnType>;
+    returnTypeBuilder: InvitationGetInvitationFunctionReturnType.TypeBuilder;
 }
-export declare namespace InvitationGetInvitationFunction {
-    type PersonIdOrPersons = {
-        personId: Person.Id;
+export type PersonIdOrPersons = {
+    personId: Person.Id;
+} | {
+    persons: {
+        id: Person.Id;
+        properties: PersonPrivateProperties;
+    }[];
+};
+export declare namespace PersonIdOrPersons {
+    type Flatten = {
+        personId: Person.Id.Flatten;
     } | {
         persons: {
-            id: Person.Id;
-            properties: PersonPrivateProperties;
+            id: Person.Id.Flatten;
+            properties: PersonPrivateProperties.Flatten;
         }[];
     };
-    namespace PersonIdOrPersons {
-        type Flatten = {
-            personId: Person.Id.Flatten;
-        } | {
-            persons: {
-                id: Person.Id.Flatten;
-                properties: PersonPrivateProperties.Flatten;
-            }[];
-        };
-    }
-    class ReturnType implements Flattable<ReturnType.Flatten> {
-        teamId: Team.Id;
-        private personIdOrPersons;
-        private constructor();
-        static from(teamId: Team.Id, personId: Person.Id): ReturnType;
-        static from(teamId: Team.Id, persons: {
-            id: Person.Id;
-            properties: PersonPrivateProperties;
-        }[]): ReturnType;
-        get personId(): Person.Id | null;
-        get persons(): {
-            id: Person.Id;
-            properties: PersonPrivateProperties;
-        }[] | null;
-        get flatten(): ReturnType.Flatten;
-    }
-    namespace ReturnType {
-        type Flatten = {
-            teamId: Team.Id.Flatten;
-        } & InvitationGetInvitationFunction.PersonIdOrPersons.Flatten;
-        class TypeBuilder implements ITypeBuilder<Flatten, ReturnType> {
-            build(value: Flatten): ReturnType;
-        }
-        const builder: TypeBuilder;
+}
+export declare class InvitationGetInvitationFunctionReturnType implements Flattable<InvitationGetInvitationFunctionReturnType.Flatten> {
+    teamId: Team.Id;
+    teamName: string;
+    private personIdOrPersons;
+    private constructor();
+    static from(teamId: Team.Id, teamName: string, personId: Person.Id): InvitationGetInvitationFunctionReturnType;
+    static from(teamId: Team.Id, teamName: string, persons: {
+        id: Person.Id;
+        properties: PersonPrivateProperties;
+    }[]): InvitationGetInvitationFunctionReturnType;
+    get personId(): Person.Id | null;
+    get persons(): {
+        id: Person.Id;
+        properties: PersonPrivateProperties;
+    }[] | null;
+    get flatten(): InvitationGetInvitationFunctionReturnType.Flatten;
+}
+export declare namespace InvitationGetInvitationFunctionReturnType {
+    type Flatten = {
+        teamId: Team.Id.Flatten;
+        teamName: string;
+    } & PersonIdOrPersons.Flatten;
+    class TypeBuilder implements ITypeBuilder<Flatten, InvitationGetInvitationFunctionReturnType> {
+        build(value: Flatten): InvitationGetInvitationFunctionReturnType;
     }
+    const builder: TypeBuilder;
 }

package/lib/src/functions/invitation/getInvitation.js

@@ -1,96 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvitationGetInvitationFunction = void 0;
+exports.InvitationGetInvitationFunctionReturnType = exports.InvitationGetInvitationFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
-const Firestore_1 = require("../../Firestore");
-const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class InvitationGetInvitationFunction extends firebase_function_1.FirebaseFunction {
+class InvitationGetInvitationFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = types_1.Invitation.Id.builder;
-    returnTypeBuilder = InvitationGetInvitationFunction.ReturnType.builder;
-    async execute(invitationId) {
-        if (this.userId === null)
-            throw new firebase_function_1.FunctionsError('unauthenticated', 'User not authenticated');
-        const invitationSnapshot = await Firestore_1.Firestore.shared.invitation(invitationId).snapshot();
-        if (!invitationSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Invitation not found');
-        const invitation = types_1.Invitation.builder.build(invitationSnapshot.data);
-        if (invitation.personId !== null)
-            return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, invitation.personId);
-        const personSnapshots = await Firestore_1.Firestore.shared.persons(invitation.teamId).documentSnapshots();
-        const persons = (0, typescript_common_functionality_1.compactMap)(personSnapshots, personSnapshot => {
-            if (!personSnapshot.exists)
-                return null;
-            const person = types_1.Person.builder.build(personSnapshot.data);
-            if (person.signInProperties !== null)
-                return null;
-            return {
-                id: person.id,
-                properties: person.properties
-            };
-        });
-        return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, persons);
-    }
+    returnTypeBuilder = InvitationGetInvitationFunctionReturnType.builder;
 }
-exports.InvitationGetInvitationFunction = InvitationGetInvitationFunction;
-(function (InvitationGetInvitationFunction) {
-    class ReturnType {
-        teamId;
-        personIdOrPersons;
-        constructor(teamId, personIdOrPersons) {
-            this.teamId = teamId;
-            this.personIdOrPersons = personIdOrPersons;
-        }
-        static from(teamId, personIdOrPersons) {
-            if (Array.isArray(personIdOrPersons)) {
-                return new ReturnType(teamId, {
-                    persons: personIdOrPersons
-                });
-            }
-            return new ReturnType(teamId, {
-                personId: personIdOrPersons
+exports.InvitationGetInvitationFunctionBase = InvitationGetInvitationFunctionBase;
+class InvitationGetInvitationFunctionReturnType {
+    teamId;
+    teamName;
+    personIdOrPersons;
+    constructor(teamId, teamName, personIdOrPersons) {
+        this.teamId = teamId;
+        this.teamName = teamName;
+        this.personIdOrPersons = personIdOrPersons;
+    }
+    static from(teamId, teamName, personIdOrPersons) {
+        if (Array.isArray(personIdOrPersons)) {
+            return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
+                persons: personIdOrPersons
             });
         }
-        get personId() {
-            if (!('personId' in this.personIdOrPersons))
-                return null;
-            return this.personIdOrPersons.personId;
-        }
-        get persons() {
-            if (!('persons' in this.personIdOrPersons))
-                return null;
-            return this.personIdOrPersons.persons;
-        }
-        get flatten() {
-            if ('personId' in this.personIdOrPersons) {
-                return {
-                    teamId: this.teamId.flatten,
-                    personId: this.personIdOrPersons.personId.flatten
-                };
-            }
+        return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
+            personId: personIdOrPersons
+        });
+    }
+    get personId() {
+        if (!('personId' in this.personIdOrPersons))
+            return null;
+        return this.personIdOrPersons.personId;
+    }
+    get persons() {
+        if (!('persons' in this.personIdOrPersons))
+            return null;
+        return this.personIdOrPersons.persons;
+    }
+    get flatten() {
+        if ('personId' in this.personIdOrPersons) {
             return {
                 teamId: this.teamId.flatten,
-                persons: this.personIdOrPersons.persons.map(person => ({
-                    id: person.id.flatten,
-                    properties: person.properties.flatten
-                }))
+                teamName: this.teamName,
+                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
+            }))
+        };
     }
-    InvitationGetInvitationFunction.ReturnType = ReturnType;
-    (function (ReturnType) {
-        class TypeBuilder {
-            build(value) {
-                if ('personId' in value) {
-                    return ReturnType.from(types_1.Team.Id.builder.build(value.teamId), types_1.Person.Id.builder.build(value.personId));
-                }
-                return ReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.persons.map(person => ({
-                    id: types_1.Person.Id.builder.build(person.id),
-                    properties: types_1.PersonPrivateProperties.builder.build(person.properties)
-                })));
+}
+exports.InvitationGetInvitationFunctionReturnType = InvitationGetInvitationFunctionReturnType;
+(function (InvitationGetInvitationFunctionReturnType) {
+    class TypeBuilder {
+        build(value) {
+            if ('personId' in value) {
+                return InvitationGetInvitationFunctionReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, types_1.Person.Id.builder.build(value.personId));
             }
+            return InvitationGetInvitationFunctionReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, value.persons.map(person => ({
+                id: types_1.Person.Id.builder.build(person.id),
+                properties: types_1.PersonPrivateProperties.builder.build(person.properties)
+            })));
         }
-        ReturnType.TypeBuilder = TypeBuilder;
-        ReturnType.builder = new TypeBuilder();
-    })(ReturnType = InvitationGetInvitationFunction.ReturnType || (InvitationGetInvitationFunction.ReturnType = {}));
-})(InvitationGetInvitationFunction || (exports.InvitationGetInvitationFunction = InvitationGetInvitationFunction = {}));
+    }
+    InvitationGetInvitationFunctionReturnType.TypeBuilder = TypeBuilder;
+    InvitationGetInvitationFunctionReturnType.builder = new TypeBuilder();
+})(InvitationGetInvitationFunctionReturnType || (exports.InvitationGetInvitationFunctionReturnType = InvitationGetInvitationFunctionReturnType = {}));

package/lib/src/functions/invitation/invite.d.ts

@@ -1,7 +1,6 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
-export declare class InvitationInviteFunction extends FirebaseFunction<Invitation, Invitation.Id> {
+export declare abstract class InvitationInviteFunctionBase extends FirebaseFunction<Invitation, Invitation.Id> {
     parametersBuilder: Invitation.TypeBuilder;
     returnTypeBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "invitation">;
-    execute(invitation: Invitation): Promise<Invitation.Id>;
 }

package/lib/src/functions/invitation/invite.js

@@ -1,25 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvitationInviteFunction = void 0;
+exports.InvitationInviteFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
-const checkAuthentication_1 = require("../../checkAuthentication");
-const Firestore_1 = require("../../Firestore");
-class InvitationInviteFunction extends firebase_function_1.FirebaseFunction {
+class InvitationInviteFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = types_1.Invitation.builder;
     returnTypeBuilder = types_1.Invitation.Id.builder;
-    async execute(invitation) {
-        await (0, checkAuthentication_1.checkAuthentication)(this.userId, invitation.teamId, 'team-manager');
-        if (invitation.personId !== null) {
-            const personSnapshot = await Firestore_1.Firestore.shared.person(invitation.teamId, invitation.personId).snapshot();
-            if (!personSnapshot.exists)
-                throw new firebase_function_1.FunctionsError('not-found', 'Person not found');
-            if (personSnapshot.data.signInProperties !== null)
-                throw new firebase_function_1.FunctionsError('already-exists', 'Person already has an account');
-        }
-        const invitationId = invitation.createId();
-        await Firestore_1.Firestore.shared.invitation(invitationId).set(invitation);
-        return invitationId;
-    }
 }
-exports.InvitationInviteFunction = InvitationInviteFunction;
+exports.InvitationInviteFunctionBase = InvitationInviteFunctionBase;

package/lib/src/functions/invitation/register.d.ts

@@ -1,19 +1,14 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team, User } from '../../types';
 import { ObjectTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare namespace InvitationRegisterFunction {
-    type Parameters = {
-        teamId: Team.Id;
-        personId: Person.Id;
-    };
-}
-export declare class InvitationRegisterFunction extends FirebaseFunction<InvitationRegisterFunction.Parameters, User> {
+export type InvitationRegisterFunctionParameters = {
+    teamId: Team.Id;
+    personId: Person.Id;
+};
+export declare abstract class InvitationRegisterFunctionBase extends FirebaseFunction<InvitationRegisterFunctionParameters, User> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
-    }, InvitationRegisterFunction.Parameters>;
+    }, InvitationRegisterFunctionParameters>;
     returnTypeBuilder: User.TypeBuilder;
-    execute(parameters: InvitationRegisterFunction.Parameters): Promise<User>;
-    private getUser;
-    private removeUserInvitation;
 }

package/lib/src/functions/invitation/register.js

@@ -1,50 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvitationRegisterFunction = void 0;
+exports.InvitationRegisterFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
-const Firestore_1 = require("../../Firestore");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class InvitationRegisterFunction extends firebase_function_1.FirebaseFunction {
+class InvitationRegisterFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder
     });
     returnTypeBuilder = types_1.User.builder;
-    async execute(parameters) {
-        if (this.userId === null)
-            throw new firebase_function_1.FunctionsError('unauthenticated', 'User not authenticated');
-        const userId = types_1.User.Id.builder.build(this.userId);
-        const user = await this.getUser(userId);
-        if (user.teams.has(parameters.teamId))
-            throw new firebase_function_1.FunctionsError('already-exists', 'User already in team');
-        const teamSnapshot = await Firestore_1.Firestore.shared.team(parameters.teamId).snapshot();
-        if (!teamSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Team not found');
-        const team = types_1.Team.builder.build(teamSnapshot.data);
-        const personSnapshot = await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Person not found');
-        const person = types_1.Person.builder.build(personSnapshot.data);
-        if (person.signInProperties !== null)
-            throw new firebase_function_1.FunctionsError('already-exists', 'Person already registered');
-        await this.removeUserInvitation(parameters.teamId, parameters.personId);
-        user.teams.set(parameters.teamId, new types_1.User.TeamProperties(team.name, parameters.personId));
-        await Firestore_1.Firestore.shared.user(userId).set(user);
-        person.signInProperties = new types_1.PersonSignInProperties(userId, typescript_common_functionality_1.UtcDate.now);
-        await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-        return user;
-    }
-    async getUser(userId) {
-        const userSnapshot = await Firestore_1.Firestore.shared.user(userId).snapshot();
-        if (userSnapshot.exists)
-            return types_1.User.builder.build(userSnapshot.data);
-        return new types_1.User(userId);
-    }
-    async removeUserInvitation(teamId, personId) {
-        const invitation = new types_1.Invitation(teamId, personId);
-        const invitationId = invitation.createId();
-        await Firestore_1.Firestore.shared.invitation(invitationId).remove();
-    }
 }
-exports.InvitationRegisterFunction = InvitationRegisterFunction;
+exports.InvitationRegisterFunctionBase = InvitationRegisterFunctionBase;

package/lib/src/functions/invitation/withdraw.d.ts

@@ -1,8 +1,7 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare class InvitationWithdrawFunction extends FirebaseFunction<Invitation, void> {
+export declare abstract class InvitationWithdrawFunctionBase extends FirebaseFunction<Invitation, void> {
     parametersBuilder: Invitation.TypeBuilder;
     returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(invitation: Invitation): Promise<void>;
 }

package/lib/src/functions/invitation/withdraw.js

@@ -1,21 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvitationWithdrawFunction = void 0;
+exports.InvitationWithdrawFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
-const checkAuthentication_1 = require("../../checkAuthentication");
-const Firestore_1 = require("../../Firestore");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class InvitationWithdrawFunction extends firebase_function_1.FirebaseFunction {
+class InvitationWithdrawFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = types_1.Invitation.builder;
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
-    async execute(invitation) {
-        await (0, checkAuthentication_1.checkAuthentication)(this.userId, invitation.teamId, 'team-manager');
-        const invitationId = invitation.createId();
-        const invitationSnapshot = await Firestore_1.Firestore.shared.invitation(invitationId).snapshot();
-        if (!invitationSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Invitation not found');
-        await Firestore_1.Firestore.shared.invitation(invitationId).remove();
-    }
 }
-exports.InvitationWithdrawFunction = InvitationWithdrawFunction;
+exports.InvitationWithdrawFunctionBase = InvitationWithdrawFunctionBase;

package/lib/src/functions/notification/register.d.ts

@@ -1,19 +1,16 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare namespace NotificationRegisterFunction {
-    type Parameters = {
-        teamId: Team.Id;
-        personId: Person.Id;
-        token: string;
-    };
-}
-export declare class NotificationRegisterFunction extends FirebaseFunction<NotificationRegisterFunction.Parameters, void> {
+export type NotificationRegisterFunctionParameters = {
+    teamId: Team.Id;
+    personId: Person.Id;
+    token: string;
+};
+export declare abstract class NotificationRegisterFunctionBase extends FirebaseFunction<NotificationRegisterFunctionParameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
         token: string;
-    }, NotificationRegisterFunction.Parameters>;
+    }, NotificationRegisterFunctionParameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(parameters: NotificationRegisterFunction.Parameters): Promise<void>;
 }

package/lib/src/functions/notification/register.js

@@ -1,27 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationRegisterFunction = void 0;
-const NotificationProperties_1 = require("../../types/NotificationProperties");
+exports.NotificationRegisterFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-const Firestore_1 = require("../../Firestore");
-class NotificationRegisterFunction extends firebase_function_1.FirebaseFunction {
+class NotificationRegisterFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder,
         token: new typescript_common_functionality_1.ValueTypeBuilder()
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
-    async execute(parameters) {
-        const personSnapshot = await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Person not found');
-        const person = types_1.Person.builder.build(personSnapshot.data);
-        if (person.signInProperties === null)
-            throw new firebase_function_1.FunctionsError('unauthenticated', 'Person not signed in');
-        person.signInProperties.notificationProperties.tokens.set(NotificationProperties_1.NotificationProperties.TokenId.create(parameters.token), parameters.token);
-        await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-    }
 }
-exports.NotificationRegisterFunction = NotificationRegisterFunction;
+exports.NotificationRegisterFunctionBase = NotificationRegisterFunctionBase;

package/lib/src/functions/notification/subscribe.d.ts

@@ -1,19 +1,16 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { NotificationProperties, Person, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare namespace NotificationSubscribeFunction {
-    type Parameters = {
-        teamId: Team.Id;
-        personId: Person.Id;
-        subscriptions: NotificationProperties.Subscription[];
-    };
-}
-export declare class NotificationSubscribeFunction extends FirebaseFunction<NotificationSubscribeFunction.Parameters, void> {
+export type NotificationSubscribeFunctionParameters = {
+    teamId: Team.Id;
+    personId: Person.Id;
+    subscriptions: NotificationProperties.Subscription[];
+};
+export declare abstract class NotificationSubscribeFunctionBase extends FirebaseFunction<NotificationSubscribeFunctionParameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
-        subscriptions: NotificationProperties.Subscription[];
-    }, NotificationSubscribeFunction.Parameters>;
+        subscriptions: ("new-fine" | "fine-reminder" | "fine-state-change")[];
+    }, NotificationSubscribeFunctionParameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(parameters: NotificationSubscribeFunction.Parameters): Promise<void>;
 }

package/lib/src/functions/notification/subscribe.js

@@ -1,26 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationSubscribeFunction = void 0;
+exports.NotificationSubscribeFunctionBase = void 0;
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-const Firestore_1 = require("../../Firestore");
-class NotificationSubscribeFunction extends firebase_function_1.FirebaseFunction {
+class NotificationSubscribeFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder,
         subscriptions: new typescript_common_functionality_1.ArrayTypeBuilder(new typescript_common_functionality_1.ValueTypeBuilder())
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
-    async execute(parameters) {
-        const personSnapshot = await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Person not found');
-        const person = types_1.Person.builder.build(personSnapshot.data);
-        if (person.signInProperties === null)
-            throw new firebase_function_1.FunctionsError('unauthenticated', 'Person not signed in');
-        person.signInProperties.notificationProperties.subscriptions = parameters.subscriptions;
-        await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-    }
 }
-exports.NotificationSubscribeFunction = NotificationSubscribeFunction;
+exports.NotificationSubscribeFunctionBase = NotificationSubscribeFunctionBase;

package/lib/src/functions/paypalMe/edit.d.ts

@@ -1,17 +1,14 @@
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Team } from '../../types';
-export declare namespace PaypalMeEditFunction {
-    type Parameters = {
-        teamId: Team.Id;
-        paypalMeLink: string | null;
-    };
-}
-export declare class PaypalMeEditFunction extends FirebaseFunction<PaypalMeEditFunction.Parameters, void> {
+export type PaypalMeEditFunctionParameters = {
+    teamId: Team.Id;
+    paypalMeLink: string | null;
+};
+export declare abstract class PaypalMeEditFunctionBase extends FirebaseFunction<PaypalMeEditFunctionParameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         paypalMeLink: string | null;
-    }, PaypalMeEditFunction.Parameters>;
+    }, PaypalMeEditFunctionParameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(parameters: PaypalMeEditFunction.Parameters): Promise<void>;
 }

package/lib/src/functions/paypalMe/edit.js

@@ -1,25 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaypalMeEditFunction = void 0;
+exports.PaypalMeEditFunctionBase = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
-const checkAuthentication_1 = require("../../checkAuthentication");
-const Firestore_1 = require("../../Firestore");
-class PaypalMeEditFunction extends firebase_function_1.FirebaseFunction {
+class PaypalMeEditFunctionBase extends firebase_function_1.FirebaseFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         paypalMeLink: new typescript_common_functionality_1.ValueTypeBuilder()
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
-    async execute(parameters) {
-        await (0, checkAuthentication_1.checkAuthentication)(this.userId, parameters.teamId, 'team-manager');
-        const teamSnapshot = await Firestore_1.Firestore.shared.team(parameters.teamId).snapshot();
-        if (!teamSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Team not found');
-        const team = types_1.Team.builder.build(teamSnapshot.data);
-        team.paypalMeLink = parameters.paypalMeLink;
-        await Firestore_1.Firestore.shared.team(parameters.teamId).set(team);
-    }
 }
-exports.PaypalMeEditFunction = PaypalMeEditFunction;
+exports.PaypalMeEditFunctionBase = PaypalMeEditFunctionBase;

package/lib/src/functions/person/add.d.ts

@@ -1,14 +1,12 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare namespace PersonAddFunction {
-    type Parameters = {
-        teamId: Team.Id;
-        id: Person.Id;
-        properties: PersonPrivateProperties;
-    };
-}
-export declare class PersonAddFunction extends FirebaseFunction<PersonAddFunction.Parameters, void> {
+export type PersonAddFunctionParameters = {
+    teamId: Team.Id;
+    id: Person.Id;
+    properties: PersonPrivateProperties;
+};
+export declare abstract class PersonAddFunctionBase extends FirebaseFunction<PersonAddFunctionParameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         id: string;
@@ -16,7 +14,6 @@ export declare class PersonAddFunction extends FirebaseFunction<PersonAddFunctio
             firstName: string;
             lastName: string | null;
         };
-    }, PersonAddFunction.Parameters>;
+    }, PersonAddFunctionParameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(parameters: PersonAddFunction.Parameters): Promise<void>;
 }