@stamhoofd/models 2.1.1

package/src/models/UsedRegisterCode.ts

@@ -0,0 +1,166 @@
+import { column, Model } from "@simonbackx/simple-database";
+import { Email } from "@stamhoofd/email";
+import { Formatter } from "@stamhoofd/utility";
+import { v4 as uuidv4 } from "uuid";
+
+import { Organization, RegisterCode, STCredit, STPendingInvoice } from "./";
+import { STInvoiceItem } from "@stamhoofd/structures";
+import { QueueHandler } from "@stamhoofd/queues";
+
+export class UsedRegisterCode extends Model {
+    static table = "used_register_codes";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    code: string;
+
+    /**
+     * Code is used by...
+     */
+    @column({ type: "string" })
+    organizationId: string;
+
+    /**
+     * Set if this has been rewarded
+     */
+    @column({ type: "string", nullable: true })
+    creditId: string | null = null;
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static async getFor(organizationId: string): Promise<UsedRegisterCode | undefined> {
+        const code = await this.where({ organizationId }, { limit: 1 })
+        return code[0] ?? undefined
+    }
+
+    async reward() {
+        if (this.creditId) {
+            // Already received
+            console.error("Already rewarded for used register code "+this.id)
+            return
+        }
+
+        const code = await RegisterCode.getByID(this.code)
+        if (!code || !code.organizationId) {
+            console.error("Couldn't find code "+this.code+" for used register code "+this.id)
+            return
+        }
+
+        const organization = await Organization.getByID(this.organizationId)
+        if (!organization) {
+            console.error("Couldn't find organization with id "+this.organizationId+" for used register code "+this.id)
+            return
+        }
+
+        const receivingOrganization = await Organization.getByID(code.organizationId)
+        if (!receivingOrganization) {
+            console.error("Couldn't find receiving organization with id "+code.organizationId+" for used register code "+this.id)
+            return
+        }
+
+        const usedCount = await UsedRegisterCode.getUsedCount(this.code) + 1
+
+        const credit = new STCredit()
+        credit.organizationId = code.organizationId
+        credit.change = code.invoiceValue ? 0 : Math.min(100 * 100, usedCount * 10 * 100)
+        credit.description = organization.name+" doorverwezen 🙌"
+
+        // Expire in one year (will get extended for every purchase or activation)
+        credit.expireAt = new Date()
+        credit.expireAt.setFullYear(credit.expireAt.getFullYear() + 1)
+        credit.expireAt.setMilliseconds(0)
+
+        await credit.save()
+        this.creditId = credit.id
+        await this.save()
+
+        if (code.invoiceValue) {
+            const name = "Aankoop Stamhoofd voor " + organization.name
+            const item = STInvoiceItem.create({
+                name,
+                description: "Via doorverwijzingscode",
+                amount: 1,
+                unitPrice: code.invoiceValue,
+                canUseCredits: false
+            })
+            console.log("Scheduling code charge for ", code)
+            await QueueHandler.schedule("billing/invoices-"+receivingOrganization.id, async () => {
+                await STPendingInvoice.addItems(receivingOrganization, [item])
+            });
+        }
+
+        const admins = await receivingOrganization.getAdminToEmails()
+        if (admins) {
+            if (code.invoiceValue) {
+                Email.sendInternal({
+                    to: admins,
+                    bcc: "simon@stamhoofd.be",
+                    subject: `${organization.name} heeft jullie tegoed gebruikt`,
+                    text: "Dag "+receivingOrganization.name+",\n\n"+organization.name+" had jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren, en nu hebben ze dit ook gebruikt. Zoals afgesproken wordt hiervoor " + Formatter.price(code.invoiceValue)+ " aangerekend via jullie openstaand saldo in jullie Stamhoofd account."
+                    + "\n\n— Stamhoofd"
+                }, organization.i18n)
+
+            } else {
+                // Delay email until everything is validated and saved
+                Email.sendInternal({
+                    to: admins,
+                    bcc: "simon@stamhoofd.be",
+                    subject: "Je hebt "+Formatter.price(credit.change)+" tegoed ontvangen 💰",
+                    text: "Dag "+receivingOrganization.name+",\n\nGeweldig nieuws! "+organization.name+" had jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren, en nu hebben ze ook voor het eerst minstens één euro uitgegeven. Daardoor ontvangen jullie "+Formatter.price(credit.change)+" tegoed voor Stamhoofd (zie daarvoor Stamhoofd > Instellingen). "
+                    + (credit.change <= 90*100 ? ("Bij de volgende vereniging ontvangen jullie nog meer: "+Formatter.price(credit.change + 10*100)+". ") : "")
+                    + (credit.change <= 80*100 ? ("En dat blijft oplopen tot € 100,00 per vereniging die je aanbrengt 🎁 ") : "")
+                    + "Doe zo verder! Lees zeker onze tips na om nog een groter bedrag te verzamelen 😉\n\n— Stamhoofd"
+                }, organization.i18n)
+            }
+        }
+    }
+
+    static async getAll(code: string) {
+        const used = await UsedRegisterCode.where({ 
+            code
+        })
+        return used
+    }
+
+    static async getUsed(code: string) {
+        const used = await UsedRegisterCode.where({ 
+            code, 
+            creditId: {
+                value: null,
+                sign: "!="
+            }
+        })
+        return used
+    }
+
+    static async getUsedCount(code: string) {
+        const used = await this.getUsed(code)
+        return used.length
+    }
+}

package/src/models/User.ts

@@ -0,0 +1,445 @@
+
+import { column, Database, ManyToOneRelation, Model } from "@simonbackx/simple-database";
+import { EmailInterfaceRecipient } from "@stamhoofd/email";
+import { LoginProviderType, NewUser, Permissions, User as UserStruct,UserMeta, UserPermissions } from "@stamhoofd/structures";
+import argon2 from "argon2";
+import { v4 as uuidv4 } from "uuid";
+
+import { Organization, Platform } from "./";
+
+export class User extends Model {
+    static table = "users";
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ foreignKey: User.organization, type: "string", nullable: true })
+    organizationId: string|null;
+
+    @column({ type: "string", nullable: true })
+    firstName: string | null = null;
+
+    @column({ type: "string", nullable: true })
+    lastName: string | null = null;
+
+    @column({ type: "string" })
+    email: string;
+
+    @column({ type: "string", nullable: true })
+    password: string | null = null;
+
+    @column({ type: "boolean" })
+    verified = false
+
+    @column({ type: "json", decoder: UserPermissions, nullable: true })
+    permissions: UserPermissions | null = null
+
+    /**
+     * @deprecated
+     * use permissions
+     */
+    @column({ type: "json", decoder: Permissions, nullable: true })
+    organizationPermissions: Permissions | null = null
+
+    @column({ type: "json", decoder: UserMeta, nullable: true })
+    meta: UserMeta | null = null
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static organization = new ManyToOneRelation(Organization, "organization");
+
+    get name() {
+        if (this.firstName && this.lastName) {
+            return this.firstName + " " + this.lastName;
+        }
+
+        if (this.firstName) {
+            return this.firstName;
+        }
+
+        if (this.lastName) {
+            return this.lastName;
+        }
+
+        return null;
+    }
+
+    static async getAdmins(organizationIds: string[], options?: {verified?: boolean}) {
+        if (organizationIds.length == 0) {
+            return []
+        }
+
+        if (STAMHOOFD.userMode === 'platform') {
+            // Custom implementation
+            let global = (await User.where({ organizationId: null, permissions: { sign: "!=", value: null }}))
+            global = global.filter(u => organizationIds.find(organizationId => u.permissions?.organizationPermissions.has(organizationId)))
+
+            // Hide api accounts
+            global = global.filter(a => !a.isApiUser)
+
+            return global
+        }
+
+        const query: any = {
+            permissions: { sign: "!=", value: null }, 
+            organizationId: {sign: 'IN', value: organizationIds},
+        };
+
+        if (options?.verified !== undefined) {
+            query.verified = options.verified
+        }
+
+        return (
+            await User.where(query)
+        ).filter(a => !a.isApiUser)
+    }
+
+    static async getApiUsers(organizationIds: string[]) {
+        return organizationIds.length > 0 ? (await User.where({ permissions: { sign: "!=", value: null }, organizationId: {sign: 'IN', value: organizationIds}})).filter(a => a.isApiUser) : []
+    }
+
+    async merge(other: User) {
+        if (other.hasAccount()) {
+            // We are going to merge accounts!
+            if (this.organizationPermissions && other.organizationPermissions) {
+                this.organizationPermissions.add(other.organizationPermissions);
+            } else {
+                if (!this.organizationPermissions && other.organizationPermissions) {
+                    this.organizationPermissions = other.organizationPermissions;
+                }
+            }
+            await this.save();
+
+            if (other.firstName && !this.firstName) {
+                this.firstName = other.firstName;
+            }
+
+            if (other.lastName && !this.lastName) {
+                this.lastName = other.lastName;
+            }
+        }
+
+        const Member = (await import("./Member")).Member
+
+        // Delete placeholder account, but migrate members first
+        const members = await Member.getMembersWithRegistrationForUser(other)
+
+        if (members.length > 0) {
+            console.log("Moving members from user "+other.id+" to "+this.id)
+            await Member.users.reverse("members").link(this, members)
+        }
+
+        // Update balance items
+        const query = "UPDATE balance_items SET userId = ? WHERE userId = ?"
+        await Database.update(query, [this.id, other.id])
+
+        // Update payments
+        const query2 = "UPDATE payments SET userId = ? WHERE userId = ?"
+        await Database.update(query2, [this.id, other.id])
+
+        // Update orders
+        const query3 = "UPDATE webshop_orders SET userId = ? WHERE userId = ?"
+        await Database.update(query3, [this.id, other.id])
+
+        await other.delete()
+    }
+
+    static async login(organizationId: string|null, email: string, password: string): Promise<User | undefined> {
+        const user = await User.getForAuthentication(organizationId, email)
+        if (!user || !user.hasKeys() || user.isApiUser) {
+            return undefined
+        }
+
+        if (STAMHOOFD.environment === 'development') {
+            if (password === 'stamhoofd') {
+                return user
+            }
+        }
+
+        if (!user.password) {
+            console.log('Tried to login to a user without password', email)
+            return
+        }
+
+        try {
+            if (await argon2.verify(user.password, password)) {
+                return user
+            }
+        } catch (e) {
+            // internal failure
+            console.error(e)
+        }
+    }
+
+    /// Delete users when we delete a member
+    static async deleteForDeletedMember(memberId: string) {
+        const [rows] = await Database.delete(`DELETE ${this.table} FROM ${this.table} JOIN _members_users a ON a.usersId = ${this.table}.id LEFT JOIN _members_users b ON b.usersId = ${this.table}.id AND b.membersId != a.membersId WHERE a.membersId = ? and b.membersId is null and users.permissions is null`, [memberId]);
+        return rows
+    }
+
+    hasPasswordBasedAccount() {
+        if (this.password) {
+            return true;
+        }
+        
+        return false
+    }
+
+    get isApiUser() {
+        return !this.email.includes('@') && this.email.endsWith('.api') && this.verified
+    }
+
+    hasAccount() {
+        if (this.hasPasswordBasedAccount()) {
+            return true;
+        }
+        if ((this.meta?.loginProviderIds?.size ?? 0) > 0) {
+            return true;
+        }
+        if (this.isApiUser) {
+            return true;
+        }
+        return false
+    }
+
+    protected hasKeys() {
+        if (this.password) {
+            // Users with a password are 'real' users. Always.
+            return true;
+        }
+
+        return false;
+    }
+
+    static async getForRegister(organizationId: string|null, email: string): Promise<User | undefined> {
+        return await this.getForAuthentication(organizationId, email, {allowWithoutAccount: true})
+    }
+
+    static async getOrganizationLevelUser(organizationId: string, email: string): Promise<User | undefined> {
+        const users = await User.where({
+            email,
+            organizationId: organizationId
+        }, {
+            limit: 1
+        })
+
+        if (users.length == 0) {
+            return undefined;
+        }
+        const user = users[0]
+
+        if (!user) {
+            return undefined
+        }
+
+        return user;
+    }
+
+    static async getForAuthentication(organizationId: string|null, email: string, {allowWithoutAccount = false}: {allowWithoutAccount?: boolean} = {}): Promise<User | undefined> {
+        const users = await User.where({
+            email,
+            organizationId: STAMHOOFD.userMode === 'platform' ? null : organizationId
+        }, {
+            limit: 1
+        })
+
+        if (users.length == 0) {
+            if (organizationId && STAMHOOFD.userMode === 'organization') {
+                return this.getForAuthentication(null, email, {allowWithoutAccount})
+            }
+            return undefined;
+        }
+        const user = users[0]
+
+        if (!user || (!user.hasKeys() && !allowWithoutAccount)) {
+            if (organizationId && STAMHOOFD.userMode === 'organization') {
+                return this.getForAuthentication(null, email, {allowWithoutAccount})
+            }
+            return undefined
+        }
+
+        // Read member + address from first row
+        return user;
+    }
+
+    static async hash(password: string) {
+        const hash = await argon2.hash(password, { type: argon2.argon2id })
+        return hash
+    }
+
+    static async createInvited(
+        organization: Organization|null,
+        data: {firstName: string|null, lastName: string|null, email: string, allowPlatform?: boolean}
+    ): Promise<User | undefined> {
+        const {
+            email,
+            firstName,
+            lastName
+        } = data;
+
+        if (!organization && STAMHOOFD.userMode !== 'platform' && !data.allowPlatform) {
+            throw new Error("Missing organization")
+        }
+
+        const user = new User();
+        user.organizationId = STAMHOOFD.userMode === 'platform' ? null : (organization?.id ?? null)
+        user.id = uuidv4()
+        user.email = email;
+        user.verified = false;
+        user.firstName = firstName
+        user.lastName = lastName
+
+        try {
+            await user.save();
+        } catch (e) {
+            // Duplicate key probably
+            if (e.code && e.code == "ER_DUP_ENTRY") {
+                return;
+            }
+            throw e;
+        }
+
+        return user;
+    }
+
+    static async register(
+        organization: Organization|null,
+        data: NewUser
+    ): Promise<User | undefined> {
+        const {
+            email,
+            password,
+            id,
+            firstName,
+            lastName
+        } = data;
+
+        if (!password) {
+            throw new Error("A password is required for new users")
+        }
+
+        if (!organization && STAMHOOFD.userMode !== 'platform') {
+            throw new Error("Missing organization")
+        }
+
+        const user = new User();
+        user.organizationId = STAMHOOFD.userMode === 'platform' ? null : (organization?.id ?? null)
+        user.id = id ?? uuidv4()
+        user.email = email;
+        user.password = await this.hash(password)
+        user.verified = false;
+        user.firstName = firstName
+        user.lastName = lastName
+
+        try {
+            await user.save();
+        } catch (e) {
+            // Duplicate key probably
+            if (e.code && e.code == "ER_DUP_ENTRY") {
+                return;
+            }
+            throw e;
+        }
+
+        return user;
+    }
+
+    linkLoginProvider(type: LoginProviderType, sub: string) {
+        if (!this.meta) {
+            this.meta = UserMeta.create({})
+        }
+        this.meta.loginProviderIds.set(type, sub)
+    }
+
+    static async registerSSO(
+        organization: Organization|null,
+        data: {email, id, firstName, lastName, type: LoginProviderType, sub: string}
+    ): Promise<User | undefined> {
+        const {
+            email,
+            id,
+            firstName,
+            lastName
+        } = data;
+
+        if (STAMHOOFD.userMode === 'platform') {
+            throw new Error('SSO is disabled on platforms for now')
+        }
+
+        if (!organization) {
+            throw new Error("Missing organization")
+        }
+
+        const user = new User();
+        user.organizationId = organization.id
+        user.id = id ?? uuidv4()
+        user.email = email;
+        user.verified = false;
+        user.firstName = firstName
+        user.lastName = lastName
+        user.linkLoginProvider(data.type, data.sub)
+
+        try {
+            await user.save();
+        } catch (e) {
+            // Duplicate key probably
+            if (e.code && e.code == "ER_DUP_ENTRY") {
+                return;
+            }
+            throw e;
+        }
+
+        return user;
+    }
+
+    async changePassword(password: string) {
+        this.password = await User.hash(password)
+    }
+
+    getStructure() {
+        return UserStruct.create({
+            firstName: this.firstName,
+            lastName: this.lastName,
+            id: this.id,
+            email: this.email,
+            verified: this.verified,
+            permissions: this.permissions,
+            hasAccount: this.hasAccount()
+        });
+    }
+
+    getEmailTo(): EmailInterfaceRecipient[] {
+        return [
+           {
+                email: this.email,
+                name: this.name
+            }
+        ]
+    }
+
+}

package/src/models/UserPermissions.ts

@@ -0,0 +1,54 @@
+
+import { column, ManyToOneRelation, Model } from "@simonbackx/simple-database";
+import { Permissions } from "@stamhoofd/structures";
+import { v4 as uuidv4 } from "uuid";
+
+import { Organization, User } from "./";
+
+export class UserPermissions extends Model {
+    static table = "user_permissions";
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ foreignKey: UserPermissions.organization, type: "string" })
+    organizationId: string;
+
+    @column({ foreignKey: UserPermissions.user, type: "string" })
+    userId: string;
+
+    @column({ type: "json", decoder: Permissions, nullable: true })
+    permissions: Permissions | null = null
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static organization = new ManyToOneRelation(Organization, "organization");
+    static user = new ManyToOneRelation(User, "user");
+
+    
+}