@stevenkellner/team-conduct-api 1.0.5 → 1.0.6

package/src/types/FineAmount.ts

@@ -0,0 +1,123 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { MoneyAmount } from './MoneyAmount';
+import * as i18n from 'i18n';
+import { Configuration } from './Configuration';
+
+export type FineAmount =
+    | FineAmount.Money
+    | FineAmount.Item;
+
+export namespace FineAmount {
+
+    export class Money implements Flattable<Money.Flatten> {
+
+        public constructor(
+            public amount: MoneyAmount
+        ) {}
+
+        public formatted(configuration: Configuration): string {
+            return this.amount.formatted(configuration.currency);
+        }
+
+        public get flatten(): Money.Flatten {
+            return {
+                type: 'money',
+                amount: this.amount.flatten
+            };
+        }
+    }
+
+    export namespace Money {
+
+        export type Flatten = {
+            type: 'money',
+            amount: MoneyAmount.Flatten
+        }
+
+        export class TypeBuilder implements ITypeBuilder<Flatten, Money> {
+
+            public build(value: Flatten): Money {
+                return new Money(MoneyAmount.builder.build(value.amount));
+            }
+        }
+
+        export const builder = new TypeBuilder();
+    }
+
+    export class Item implements Flattable<Item.Flatten> {
+
+        public constructor(
+            public item: Item.Type,
+            public count: number
+        ) {}
+
+        public formatted(configuration: Configuration): string {
+            const numberFormat = Intl.NumberFormat(configuration.locale, {
+                minimumFractionDigits: 0,
+                maximumFractionDigits: 0
+            });
+            if (this.count === 1)
+                return i18n.__(`FineAmount.Item.Type.${this.item}.singular`, numberFormat.format(this.count));
+            return i18n.__(`FineAmount.Item.Type.${this.item}.plural`, numberFormat.format(this.count));
+        }
+
+        public get flatten(): Item.Flatten {
+            return {
+                type: 'item',
+                item: this.item,
+                count: this.count
+            };
+        }
+    }
+
+    export namespace Item {
+
+        export type Type =
+            | 'crateOfBeer';
+
+        export namespace Type {
+
+            export const all: Type[] = ['crateOfBeer'];
+        }
+
+        export type Flatten = {
+            type: 'item',
+            item: Item.Type,
+            count: number
+        }
+
+        export class TypeBuilder implements ITypeBuilder<Flatten, Item> {
+
+            public build(value: Flatten): Item {
+                return new Item(value.item, value.count);
+            }
+        }
+
+        export const builder = new TypeBuilder();
+    }
+
+
+    export function money(MoneyAmount: MoneyAmount): Money {
+        return new Money(MoneyAmount);
+    }
+
+    export function item(item: Item.Type, count: number): Item {
+        return new Item(item, count);
+    }
+
+    export type Flatten = Money.Flatten | Item.Flatten;
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, FineAmount> {
+
+        public build(value: Flatten): FineAmount {
+            switch (value.type) {
+            case 'money':
+                return Money.builder.build(value);
+            case 'item':
+                return Item.builder.build(value);
+            }
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/FineTemplate.ts

@@ -0,0 +1,55 @@
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+import { FineAmount } from './FineAmount';
+import { FineTemplateRepetition } from './FineTemplateRepetition';
+
+export class FineTemplate implements Flattable<FineTemplate.Flatten> {
+
+    public constructor(
+        public id: FineTemplate.Id,
+        public reason: string,
+        public amount: FineAmount,
+        public repetition: FineTemplateRepetition | null
+    ) {}
+
+    public get flatten(): FineTemplate.Flatten {
+        return {
+            id: this.id.flatten,
+            reason: this.reason,
+            amount: this.amount.flatten,
+            repetition: this.repetition === null ? null : this.repetition.flatten
+        };
+    }
+}
+
+export namespace FineTemplate {
+
+    export type Id = Tagged<Guid, 'fineTemplate'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('fineTemplate' as const, Guid.builder);
+    }
+
+    export type Flatten = {
+        id: Id.Flatten,
+        reason: string,
+        amount: FineAmount.Flatten,
+        repetition: FineTemplateRepetition.Flatten | null
+    };
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, FineTemplate> {
+
+        public build(value: Flatten): FineTemplate {
+            return new FineTemplate(
+                Id.builder.build(value.id),
+                value.reason,
+                FineAmount.builder.build(value.amount),
+                value.repetition === null ? null : FineTemplateRepetition.builder.build(value.repetition)
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/FineTemplateRepetition.ts

@@ -0,0 +1,54 @@
+import { Flattable, ITypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export class FineTemplateRepetition implements Flattable<FineTemplateRepetition.Flatten> {
+
+    public constructor(
+        public item: FineTemplateRepetition.Item,
+        public maxCount: number | null
+    ) {}
+
+    public get flatten(): FineTemplateRepetition.Flatten {
+        return {
+            item: this.item,
+            maxCount: this.maxCount
+        };
+    }
+}
+
+export namespace FineTemplateRepetition {
+
+    export type Item =
+        | 'minute'
+        | 'day'
+        | 'item'
+        | 'count';
+
+    export namespace Item {
+
+        export const all: Item[] = [
+            'minute',
+            'day',
+            'item',
+            'count'
+        ];
+
+        export const builder = new ValueTypeBuilder<Item>();
+    }
+
+    export type Flatten = {
+        item: Item,
+        maxCount: number | null
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, FineTemplateRepetition> {
+
+        public build(flatten: Flatten): FineTemplateRepetition {
+            return new FineTemplateRepetition(
+                flatten.item,
+                flatten.maxCount
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/Invitation.ts

@@ -0,0 +1,56 @@
+import { BytesCoder, Flattable, ITypeBuilder, Sha512, Tagged, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Team } from './Team';
+import { Person } from './Person';
+
+export class Invitation implements Flattable<Invitation.Flatten> {
+
+    constructor(
+        public teamId: Team.Id,
+        public personId: Person.Id
+    ) {}
+
+    public createId(): Invitation.Id {
+        const hasher = new Sha512();
+        const teamIdBytes = BytesCoder.fromUtf8(this.teamId.guidString);
+        const personIdBytes = BytesCoder.fromUtf8(this.personId.guidString);
+        const hashedInvitationBytes = hasher.hash(new Uint8Array([...teamIdBytes, ...personIdBytes]));
+        const rawId = BytesCoder.toHex(hashedInvitationBytes).slice(0, 12);
+        return new Tagged(rawId, 'invitation');
+    }
+
+    public get flatten(): Invitation.Flatten {
+        return {
+            teamId: this.teamId.flatten,
+            personId: this.personId.flatten
+        };
+    }
+}
+
+export namespace Invitation {
+
+    export type Id = Tagged<string, 'invitation'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('invitation' as const, new ValueTypeBuilder<string>());
+    }
+
+    export type Flatten = {
+        teamId: Team.Id.Flatten,
+        personId: Person.Id.Flatten
+    };
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, Invitation> {
+
+        public build(value: Flatten): Invitation {
+            return new Invitation(
+                Team.Id.builder.build(value.teamId),
+                Person.Id.builder.build(value.personId)
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/MoneyAmount.ts

@@ -0,0 +1,41 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import * as i18n from 'i18n';
+import { Configuration } from './Configuration';
+
+export class MoneyAmount implements Flattable<MoneyAmount.Flatten> {
+
+    public constructor(
+        public value: number,
+        public subunitValue: number
+    ) {}
+
+    public static zero(): MoneyAmount {
+        return new MoneyAmount(0, 0);
+    }
+
+    public formatted(currency: Configuration.Currency): string {
+        const numberFormat = Intl.NumberFormat(i18n.getLocale(), {
+            style: 'currency',
+            currency: currency
+        });
+        return numberFormat.format(this.value + this.subunitValue / 100);
+    }
+
+    public get flatten(): MoneyAmount.Flatten {
+        return this.value + this.subunitValue / 100;
+    }
+}
+
+export namespace MoneyAmount {
+
+    export type Flatten = number;
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, MoneyAmount> {
+
+        public build(value: Flatten): MoneyAmount {
+            return new MoneyAmount(Math.floor(value), Math.round((value - Math.floor(value)) * 100));
+        }
+    }
+
+    export const builder = new MoneyAmount.TypeBuilder();
+}

package/src/types/NotificationProperties.ts

@@ -0,0 +1,67 @@
+import { BytesCoder, Dictionary, Flattable, ITypeBuilder, Sha512, Tagged, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export class NotificationProperties implements Flattable<NotificationProperties.Flatten> {
+
+    public constructor(
+        public tokens: Dictionary<NotificationProperties.TokenId, string> = new Dictionary(NotificationProperties.TokenId.builder),
+        public subscriptions: NotificationProperties.Subscription[] = []
+    ) {}
+
+    public get flatten(): NotificationProperties.Flatten {
+        return {
+            tokens: this.tokens.flatten,
+            subscriptions: this.subscriptions
+        };
+    }
+}
+
+export namespace NotificationProperties {
+
+    export type TokenId = Tagged<string, 'notificationToken'>;
+
+    export namespace TokenId {
+
+        export function create(token: string): TokenId {
+            const hasher = new Sha512();
+            const tokenBytes = BytesCoder.fromUtf8(token);
+            const tokenIdBytes = hasher.hash(tokenBytes);
+            const tokenId = BytesCoder.toHex(tokenIdBytes);
+            const rawId = tokenId.slice(0, 16);
+            return new Tagged(rawId, 'notificationToken');
+        }
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('notificationToken' as const, new ValueTypeBuilder<string>());
+    }
+
+    export type Subscription =
+        | 'new-fine'
+        | 'fine-reminder'
+        | 'fine-state-change';
+
+    export namespace Subscription {
+
+        export const all: Subscription[] = [
+            'new-fine',
+            'fine-reminder',
+            'fine-state-change'
+        ]
+
+        export const builder = new ValueTypeBuilder<Subscription>();
+    }
+
+    export type Flatten = {
+        tokens: Dictionary.Flatten<string>,
+        subscriptions: Subscription[]
+    };
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, NotificationProperties> {
+
+        public build(value: Flatten): NotificationProperties {
+            return new NotificationProperties(Dictionary.builder(TokenId.builder, new ValueTypeBuilder<string>()).build(value.tokens), value.subscriptions);
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/PayedState.ts

@@ -0,0 +1,12 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export type PayedState =
+    | 'payed'
+    | 'notPayed';
+
+export namespace PayedState {
+
+    export const all: PayedState[] = ['payed', 'notPayed'];
+
+    export const builder = new ValueTypeBuilder<PayedState>();
+}

package/src/types/Person.ts

@@ -0,0 +1,56 @@
+import { PersonPrivateProperties } from './PersonPrivateProperties';
+import { PersonSignInProperties } from './PersonSignInProperties';
+import { Fine } from './Fine';
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+
+export class Person implements Flattable<Person.Flatten> {
+
+    public constructor(
+        public id: Person.Id,
+        public properties: PersonPrivateProperties,
+        public fineIds: Fine.Id[] = [],
+        public signInProperties: PersonSignInProperties | null = null
+    ) {}
+
+    public get flatten(): Person.Flatten {
+        return {
+            id: this.id.flatten,
+            properties: this.properties.flatten,
+            fineIds: this.fineIds.map(fineId => fineId.flatten),
+            signInProperties: this.signInProperties?.flatten ?? null
+        };
+    }
+}
+
+export namespace Person {
+
+    export type Id = Tagged<Guid, 'person'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('person' as const, Guid.builder);
+    }
+
+    export type Flatten = {
+        id: Id.Flatten,
+        properties: PersonPrivateProperties.Flatten,
+        fineIds: Fine.Id.Flatten[],
+        signInProperties: PersonSignInProperties.Flatten | null,
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, Person> {
+
+        public build(value: Flatten): Person {
+            return new Person(
+                Id.builder.build(value.id),
+                PersonPrivateProperties.builder.build(value.properties),
+                value.fineIds.map(fineId => Fine.Id.builder.build(fineId)),
+                value.signInProperties ? PersonSignInProperties.builder.build(value.signInProperties) : null
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/PersonPrivateProperties.ts

@@ -0,0 +1,37 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export class PersonPrivateProperties implements Flattable<PersonPrivateProperties.Flatten> {
+
+    constructor(
+        public firstName: string,
+        public lastName: string | null
+    ) {}
+
+    public get flatten(): PersonPrivateProperties.Flatten {
+        return {
+            firstName: this.firstName,
+            lastName: this.lastName
+        };
+    }
+}
+
+export namespace PersonPrivateProperties {
+
+    export type Flatten = {
+        firstName: string;
+        lastName: string | null;
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, PersonPrivateProperties> {
+
+        public build(value: Flatten): PersonPrivateProperties {
+            return new PersonPrivateProperties(
+                value.firstName,
+                value.lastName
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}
+

package/src/types/PersonSignInProperties.ts

@@ -0,0 +1,42 @@
+import { Flattable, ITypeBuilder, UtcDate } from '@stevenkellner/typescript-common-functionality';
+import { NotificationProperties } from './NotificationProperties';
+import { User } from './User';
+import { UserRole } from './UserRole';
+
+export class PersonSignInProperties implements Flattable<PersonSignInProperties.Flatten> {
+
+    public constructor(
+        public userId: User.Id,
+        public signInDate: UtcDate,
+        public notificationProperties: NotificationProperties = new NotificationProperties(),
+        public roles: UserRole[] = []
+    ) {}
+
+    public get flatten(): PersonSignInProperties.Flatten {
+        return {
+            userId: this.userId.flatten,
+            signInDate: this.signInDate.flatten,
+            notificationProperties: this.notificationProperties.flatten,
+            roles: this.roles
+        };
+    }
+}
+
+export namespace PersonSignInProperties {
+
+    export type Flatten = {
+        userId: User.Id.Flatten
+        signInDate: UtcDate.Flatten,
+        notificationProperties: NotificationProperties.Flatten,
+        roles: UserRole[]
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, PersonSignInProperties> {
+
+        public build(value: Flatten): PersonSignInProperties {
+            return new PersonSignInProperties(User.Id.builder.build(value.userId), UtcDate.builder.build(value.signInDate), NotificationProperties.builder.build(value.notificationProperties), value.roles);
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/Team.ts

@@ -0,0 +1,49 @@
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+
+export class Team implements Flattable<Team.Flatten> {
+
+    public constructor(
+        public id: Team.Id,
+        public name: string,
+        public paypalMeLink: string | null
+    ) {}
+
+    public get flatten(): Team.Flatten {
+        return {
+            id: this.id.flatten,
+            name: this.name,
+            paypalMeLink: this.paypalMeLink
+        };
+    }
+}
+
+export namespace Team {
+
+    export type Id = Tagged<Guid, 'team'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('team' as const, Guid.builder);
+    }
+
+    export type Flatten = {
+        id: Id.Flatten,
+        name: string,
+        paypalMeLink: string | null
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, Team> {
+
+        public build(value: Flatten): Team {
+            return new Team(
+                Id.builder.build(value.id),
+                value.name,
+                value.paypalMeLink
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/User.ts

@@ -0,0 +1,76 @@
+import { Dictionary, Flattable, ITypeBuilder, Tagged, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Team } from './Team';
+import { Person } from './Person';
+
+export class User implements Flattable<User.Flatten> {
+
+    public constructor(
+        public id: User.Id,
+        public teams: Dictionary<Team.Id, User.TeamProperties> = new Dictionary(Team.Id.builder)
+    ) {}
+
+    public get flatten(): User.Flatten {
+        return {
+            id: this.id.flatten,
+            teams: this.teams.flatten
+        };
+    }
+}
+
+export namespace User {
+
+    export type Id = Tagged<string, 'user'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('user' as const, new ValueTypeBuilder<string>());
+    }
+
+    export class TeamProperties implements Flattable<TeamProperties.Flatten> {
+
+        public constructor(
+            public name: string,
+            public personId: Person.Id
+        ) {}
+
+        public get flatten(): TeamProperties.Flatten {
+            return {
+                name: this.name,
+                personId: this.personId.flatten
+            };
+        }
+    }
+
+    export namespace TeamProperties {
+
+        export type Flatten = {
+            name: string,
+            personId: Person.Id.Flatten
+        };
+
+        export class TypeBuilder implements ITypeBuilder<Flatten, TeamProperties> {
+
+            public build(value: Flatten): TeamProperties {
+                return new TeamProperties(value.name, Person.Id.builder.build(value.personId));
+            }
+        }
+
+        export const builder = new TypeBuilder();
+    }
+
+    export type Flatten = {
+        id: Id.Flatten,
+        teams: Dictionary.Flatten<TeamProperties>
+    }
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, User> {
+
+        public build(value: Flatten): User {
+            return new User(Id.builder.build(value.id), Dictionary.builder(Team.Id.builder, User.TeamProperties.builder).build(value.teams));
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/UserRole.ts

@@ -0,0 +1,19 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export type UserRole =
+    | 'person-manager'
+    | 'fineTemplate-manager'
+    | 'fine-manager'
+    | 'team-manager';
+
+export namespace UserRole {
+
+    export const all: UserRole[] = [
+        'person-manager',
+        'fineTemplate-manager',
+        'fine-manager',
+        'team-manager'
+    ];
+
+    export const builder = new ValueTypeBuilder<UserRole>();
+}