Merge branch 'redeem-contribution-link' into merge-frontend-redeem-contribution-link

.github/workflows/test.yml

@@ -528,7 +528,7 @@ jobs:
           report_name: Coverage Backend
           type: lcov
           result_path: ./backend/coverage/lcov.info
-          min_coverage: 70
+          min_coverage: 68
           token: ${{ github.token }}
 
   ##########################################################################

backend/src/config/index.ts

@@ -10,7 +10,7 @@ Decimal.set({
 })
 
 const constants = {
-  DB_VERSION: '0039-contributions_table',
+  DB_VERSION: '0040-add_contribution_link_id_to_user',
   DECAY_START_TIME: new Date('2021-05-13 17:46:31-0000'), // GMT+0
   LOG4JS_CONFIG: 'log4js-config.json',
   // default log level on production should be info

backend/src/graphql/resolver/AdminResolver.ts

@@ -600,7 +600,7 @@ interface CreationMap {
   creations: Decimal[]
 }
 
-async function getUserCreation(id: number, includePending = true): Promise<Decimal[]> {
+export const getUserCreation = async (id: number, includePending = true): Promise<Decimal[]> => {
   logger.trace('getUserCreation', id, includePending)
   const creations = await getUserCreations([id], includePending)
   return creations[0] ? creations[0].creations : FULL_CREATION_AVAILABLE
@@ -663,7 +663,11 @@ function updateCreations(creations: Decimal[], contribution: Contribution): Deci
   return creations
 }
 
-function isContributionValid(creations: Decimal[], amount: Decimal, creationDate: Date) {
+export const isContributionValid = (
+  creations: Decimal[],
+  amount: Decimal,
+  creationDate: Date,
+): boolean => {
   logger.trace('isContributionValid', creations, amount, creationDate)
   const index = getCreationIndex(creationDate.getMonth())
 

backend/src/graphql/resolver/TransactionLinkResolver.ts

@@ -1,7 +1,21 @@
+import { backendLogger as logger } from '@/server/logger'
 import { Context, getUser } from '@/server/context'
-import { Resolver, Args, Arg, Authorized, Ctx, Mutation, Query, Int } from 'type-graphql'
+import { getConnection } from '@dbTools/typeorm'
+import {
+  Resolver,
+  Args,
+  Arg,
+  Authorized,
+  Ctx,
+  Mutation,
+  Query,
+  Int,
+  createUnionType,
+} from 'type-graphql'
 import { TransactionLink } from '@model/TransactionLink'
+import { ContributionLink } from '@model/ContributionLink'
 import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
+import { Transaction as DbTransaction } from '@entity/Transaction'
 import { User as dbUser } from '@entity/User'
 import TransactionLinkArgs from '@arg/TransactionLinkArgs'
 import Paginated from '@arg/Paginated'
@@ -12,6 +26,17 @@ import { User } from '@model/User'
 import { calculateDecay } from '@/util/decay'
 import { executeTransaction } from './TransactionResolver'
 import { Order } from '@enum/Order'
+import { Contribution as DbContribution } from '@entity/Contribution'
+import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+import { getUserCreation, isContributionValid } from './AdminResolver'
+import { Decay } from '@model/Decay'
+import Decimal from 'decimal.js-light'
+import { TransactionTypeId } from '@enum/TransactionTypeId'
+
+const QueryLinkResult = createUnionType({
+  name: 'QueryLinkResult', // the name of the GraphQL union
+  types: () => [TransactionLink, ContributionLink] as const, // function that returns tuple of object types classes
+})
 
 // TODO: do not export, test it inside the resolver
 export const transactionLinkCode = (date: Date): string => {
@@ -95,15 +120,23 @@ export class TransactionLinkResolver {
   }
 
   @Authorized([RIGHTS.QUERY_TRANSACTION_LINK])
-  @Query(() => TransactionLink)
-  async queryTransactionLink(@Arg('code') code: string): Promise<TransactionLink> {
-    const transactionLink = await dbTransactionLink.findOneOrFail({ code }, { withDeleted: true })
-    const user = await dbUser.findOneOrFail({ id: transactionLink.userId })
-    let redeemedBy: User | null = null
-    if (transactionLink && transactionLink.redeemedBy) {
-      redeemedBy = new User(await dbUser.findOneOrFail({ id: transactionLink.redeemedBy }))
+  @Query(() => QueryLinkResult)
+  async queryTransactionLink(@Arg('code') code: string): Promise<typeof QueryLinkResult> {
+    if (code.match(/^CL-/)) {
+      const contributionLink = await DbContributionLink.findOneOrFail(
+        { code: code.replace('CL-', '') },
+        { withDeleted: true },
+      )
+      return new ContributionLink(contributionLink)
+    } else {
+      const transactionLink = await dbTransactionLink.findOneOrFail({ code }, { withDeleted: true })
+      const user = await dbUser.findOneOrFail({ id: transactionLink.userId })
+      let redeemedBy: User | null = null
+      if (transactionLink && transactionLink.redeemedBy) {
+        redeemedBy = new User(await dbUser.findOneOrFail({ id: transactionLink.redeemedBy }))
+      }
+      return new TransactionLink(transactionLink, new User(user), redeemedBy)
     }
-    return new TransactionLink(transactionLink, new User(user), redeemedBy)
   }
 
   @Authorized([RIGHTS.LIST_TRANSACTION_LINKS])
@@ -137,31 +170,143 @@ export class TransactionLinkResolver {
     @Ctx() context: Context,
   ): Promise<boolean> {
     const user = getUser(context)
-    const transactionLink = await dbTransactionLink.findOneOrFail({ code })
-    const linkedUser = await dbUser.findOneOrFail({ id: transactionLink.userId })
-
     const now = new Date()
 
-    if (user.id === linkedUser.id) {
-      throw new Error('Cannot redeem own transaction link.')
+    if (code.match(/^CL-/)) {
+      logger.info('redeem contribution link...')
+      const queryRunner = getConnection().createQueryRunner()
+      await queryRunner.connect()
+      await queryRunner.startTransaction('SERIALIZABLE')
+      try {
+        const contributionLink = await queryRunner.manager
+          .createQueryBuilder()
+          .select('contributionLink')
+          .from(DbContributionLink, 'contributionLink')
+          .where('contributionLink.code = :code', { code: code.replace('CL-', '') })
+          .getOne()
+        if (!contributionLink) {
+          logger.error('no contribution link found to given code:', code)
+          throw new Error('No contribution link found')
+        }
+        logger.info('...contribution link found with id', contributionLink.id)
+        if (new Date(contributionLink.validFrom).getTime() > now.getTime()) {
+          logger.error(
+            'contribution link is not valid yet. Valid from: ',
+            contributionLink.validFrom,
+          )
+          throw new Error('Contribution link not valid yet')
+        }
+        if (contributionLink.validTo) {
+          if (new Date(contributionLink.validTo).setHours(23, 59, 59) < now.getTime()) {
+            logger.error('contribution link is depricated. Valid to: ', contributionLink.validTo)
+            throw new Error('Contribution link is depricated')
+          }
+        }
+        if (contributionLink.cycle !== 'ONCE') {
+          logger.error('contribution link has unknown cycle', contributionLink.cycle)
+          throw new Error('Contribution link has unknown cycle')
+        }
+        // Test ONCE rule
+        const alreadyRedeemed = await queryRunner.manager
+          .createQueryBuilder()
+          .select('contribution')
+          .from(DbContribution, 'contribution')
+          .where('contribution.contributionLinkId = :linkId AND contribution.userId = :id', {
+            linkId: contributionLink.id,
+            id: user.id,
+          })
+          .getOne()
+        if (alreadyRedeemed) {
+          logger.error('contribution link with rule ONCE already redeemed by user with id', user.id)
+          throw new Error('Contribution link already redeemed')
+        }
+
+        const creations = await getUserCreation(user.id, false)
+        logger.info('open creations', creations)
+        if (!isContributionValid(creations, contributionLink.amount, now)) {
+          logger.error(
+            'Amount of Contribution link exceeds available amount for this month',
+            contributionLink.amount,
+          )
+          throw new Error('Amount of Contribution link exceeds available amount')
+        }
+        const contribution = new DbContribution()
+        contribution.userId = user.id
+        contribution.createdAt = now
+        contribution.contributionDate = now
+        contribution.memo = contributionLink.memo
+        contribution.amount = contributionLink.amount
+        contribution.contributionLinkId = contributionLink.id
+        await queryRunner.manager.insert(DbContribution, contribution)
+
+        const lastTransaction = await queryRunner.manager
+          .createQueryBuilder()
+          .select('transaction')
+          .from(DbTransaction, 'transaction')
+          .where('transaction.userId = :id', { id: user.id })
+          .orderBy('transaction.balanceDate', 'DESC')
+          .getOne()
+        let newBalance = new Decimal(0)
+
+        let decay: Decay | null = null
+        if (lastTransaction) {
+          decay = calculateDecay(lastTransaction.balance, lastTransaction.balanceDate, now)
+          newBalance = decay.balance
+        }
+        newBalance = newBalance.add(contributionLink.amount.toString())
+
+        const transaction = new DbTransaction()
+        transaction.typeId = TransactionTypeId.CREATION
+        transaction.memo = contribution.memo
+        transaction.userId = contribution.userId
+        transaction.previous = lastTransaction ? lastTransaction.id : null
+        transaction.amount = contribution.amount
+        transaction.creationDate = contribution.contributionDate
+        transaction.balance = newBalance
+        transaction.balanceDate = now
+        transaction.decay = decay ? decay.decay : new Decimal(0)
+        transaction.decayStart = decay ? decay.start : null
+        await queryRunner.manager.insert(DbTransaction, transaction)
+
+        contribution.confirmedAt = now
+        contribution.transactionId = transaction.id
+        await queryRunner.manager.update(DbContribution, { id: contribution.id }, contribution)
+
+        await queryRunner.commitTransaction()
+        logger.info('creation from contribution link commited successfuly.')
+      } catch (e) {
+        await queryRunner.rollbackTransaction()
+        logger.error(`Creation  from contribution link was not successful: ${e}`)
+        throw new Error(`Creation  from contribution link was not successful. ${e}`)
+      } finally {
+        await queryRunner.release()
+      }
+      return true
+    } else {
+      const transactionLink = await dbTransactionLink.findOneOrFail({ code })
+      const linkedUser = await dbUser.findOneOrFail({ id: transactionLink.userId })
+
+      if (user.id === linkedUser.id) {
+        throw new Error('Cannot redeem own transaction link.')
+      }
+
+      if (transactionLink.validUntil.getTime() < now.getTime()) {
+        throw new Error('Transaction Link is not valid anymore.')
+      }
+
+      if (transactionLink.redeemedBy) {
+        throw new Error('Transaction Link already redeemed.')
+      }
+
+      await executeTransaction(
+        transactionLink.amount,
+        transactionLink.memo,
+        linkedUser,
+        user,
+        transactionLink,
+      )
+
+      return true
     }
-
-    if (transactionLink.validUntil.getTime() < now.getTime()) {
-      throw new Error('Transaction Link is not valid anymore.')
-    }
-
-    if (transactionLink.redeemedBy) {
-      throw new Error('Transaction Link already redeemed.')
-    }
-
-    await executeTransaction(
-      transactionLink.amount,
-      transactionLink.memo,
-      linkedUser,
-      user,
-      transactionLink,
-    )
-
-    return true
   }
 }

backend/src/graphql/resolver/UserResolver.test.ts

@@ -13,6 +13,10 @@ import CONFIG from '@/config'
 import { sendAccountActivationEmail } from '@/mailer/sendAccountActivationEmail'
 import { sendResetPasswordEmail } from '@/mailer/sendResetPasswordEmail'
 import { printTimeDuration, activationLink } from './UserResolver'
+import { contributionLinkFactory } from '@/seeds/factory/contributionLink'
+// import { transactionLinkFactory } from '@/seeds/factory/transactionLink'
+import { ContributionLink } from '@model/ContributionLink'
+// import { TransactionLink } from '@entity/TransactionLink'
 
 import { logger } from '@test/testSetup'
 
@@ -69,6 +73,7 @@ describe('UserResolver', () => {
 
     let result: any
     let emailOptIn: string
+    let user: User[]
 
     beforeAll(async () => {
       jest.clearAllMocks()
@@ -86,7 +91,6 @@ describe('UserResolver', () => {
     })
 
     describe('valid input data', () => {
-      let user: User[]
       let loginEmailOptIn: LoginEmailOptIn[]
       beforeAll(async () => {
         user = await User.find()
@@ -114,6 +118,7 @@ describe('UserResolver', () => {
               deletedAt: null,
               publisherId: 1234,
               referrerId: null,
+              contributionLinkId: null,
             },
           ])
         })
@@ -195,6 +200,72 @@ describe('UserResolver', () => {
         )
       })
     })
+
+    describe('redeem codes', () => {
+      describe('contribution link', () => {
+        let link: ContributionLink
+        beforeAll(async () => {
+          // activate account of admin Peter Lustig
+          await mutate({
+            mutation: setPassword,
+            variables: { code: emailOptIn, password: 'Aa12345_' },
+          })
+          // make Peter Lustig Admin
+          const peter = await User.findOneOrFail({ id: user[0].id })
+          peter.isAdmin = new Date()
+          await peter.save()
+          // factory logs in as Peter Lustig
+          link = await contributionLinkFactory(testEnv, {
+            name: 'Dokumenta 2022',
+            memo: 'Vielen Dank für deinen Besuch bei der Dokumenta 2022',
+            amount: 200,
+            validFrom: new Date(2022, 5, 18),
+            validTo: new Date(2022, 8, 25),
+          })
+          resetToken()
+          await mutate({
+            mutation: createUser,
+            variables: { ...variables, email: 'ein@besucher.de', redeemCode: 'CL-' + link.code },
+          })
+        })
+
+        it('sets the contribution link id', async () => {
+          await expect(User.findOne({ email: 'ein@besucher.de' })).resolves.toEqual(
+            expect.objectContaining({
+              contributionLinkId: link.id,
+            }),
+          )
+        })
+      })
+
+      /* A transaction link requires GDD on account
+      describe('transaction link', () => {
+        let code: string
+        beforeAll(async () => {
+          // factory logs in as Peter Lustig
+          await transactionLinkFactory(testEnv, {
+            email: 'peter@lustig.de',
+            amount: 19.99,
+            memo: `Kein Trick, keine Zauberrei,
+bei Gradidio sei dabei!`,
+          })
+          const transactionLink = await TransactionLink.findOneOrFail()
+          resetToken()
+          await mutate({
+            mutation: createUser,
+            variables: { ...variables, email: 'neuer@user.de', redeemCode: transactionLink.code },
+          })          
+        })
+
+        it('sets the referrer id to Peter Lustigs id', async () => {
+          await expect(User.findOne({ email: 'neuer@user.de' })).resolves.toEqual(expect.objectContaining({
+            referrerId: user[0].id,
+          }))
+        })
+      })
+
+      */
+    })
   })
 
   describe('setPassword', () => {

backend/src/graphql/resolver/UserResolver.ts

@@ -8,6 +8,7 @@ import CONFIG from '@/config'
 import { User } from '@model/User'
 import { User as DbUser } from '@entity/User'
 import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
+import { ContributionLink as dbContributionLink } from '@entity/ContributionLink'
 import { encode } from '@/auth/JWT'
 import CreateUserArgs from '@arg/CreateUserArgs'
 import UnsecureLoginArgs from '@arg/UnsecureLoginArgs'
@@ -349,10 +350,20 @@ export class UserResolver {
     dbUser.passphrase = passphrase.join(' ')
     logger.debug('new dbUser=' + dbUser)
     if (redeemCode) {
-      const transactionLink = await dbTransactionLink.findOne({ code: redeemCode })
-      logger.info('redeemCode found transactionLink=' + transactionLink)
-      if (transactionLink) {
-        dbUser.referrerId = transactionLink.userId
+      if (redeemCode.match(/^CL-/)) {
+        const contributionLink = await dbContributionLink.findOne({
+          code: redeemCode.replace('CL-', ''),
+        })
+        logger.info('redeemCode found contributionLink=' + contributionLink)
+        if (contributionLink) {
+          dbUser.contributionLinkId = contributionLink.id
+        }
+      } else {
+        const transactionLink = await dbTransactionLink.findOne({ code: redeemCode })
+        logger.info('redeemCode found transactionLink=' + transactionLink)
+        if (transactionLink) {
+          dbUser.referrerId = transactionLink.userId
+        }
       }
     }
     // TODO this field has no null allowed unlike the loginServer table

backend/src/seeds/factory/contributionLink.ts

@@ -1,12 +1,13 @@
 import { ApolloServerTestClient } from 'apollo-server-testing'
 import { createContributionLink } from '@/seeds/graphql/mutations'
 import { login } from '@/seeds/graphql/queries'
+import { ContributionLink } from '@model/ContributionLink'
 import { ContributionLinkInterface } from '@/seeds/contributionLink/ContributionLinkInterface'
 
 export const contributionLinkFactory = async (
   client: ApolloServerTestClient,
   contributionLink: ContributionLinkInterface,
-): Promise<void> => {
+): Promise<ContributionLink> => {
   const { mutate, query } = client
 
   // login as admin
@@ -23,5 +24,6 @@ export const contributionLinkFactory = async (
     validTo: contributionLink.validTo ? contributionLink.validTo.toISOString() : undefined,
   }
 
-  await mutate({ mutation: createContributionLink, variables })
+  const result = await mutate({ mutation: createContributionLink, variables })
+  return result.data.createContributionLink
 }

database/entity/0040-add_contribution_link_id_to_user/User.ts

@@ -0,0 +1,79 @@
+import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, DeleteDateColumn } from 'typeorm'
+
+@Entity('users', { engine: 'InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci' })
+export class User extends BaseEntity {
+  @PrimaryGeneratedColumn('increment', { unsigned: true })
+  id: number
+
+  @Column({ name: 'public_key', type: 'binary', length: 32, default: null, nullable: true })
+  pubKey: Buffer
+
+  @Column({ name: 'privkey', type: 'binary', length: 80, default: null, nullable: true })
+  privKey: Buffer
+
+  @Column({ length: 255, unique: true, nullable: false, collation: 'utf8mb4_unicode_ci' })
+  email: string
+
+  @Column({
+    name: 'first_name',
+    length: 255,
+    nullable: true,
+    default: null,
+    collation: 'utf8mb4_unicode_ci',
+  })
+  firstName: string
+
+  @Column({
+    name: 'last_name',
+    length: 255,
+    nullable: true,
+    default: null,
+    collation: 'utf8mb4_unicode_ci',
+  })
+  lastName: string
+
+  @DeleteDateColumn()
+  deletedAt: Date | null
+
+  @Column({ type: 'bigint', default: 0, unsigned: true })
+  password: BigInt
+
+  @Column({ name: 'email_hash', type: 'binary', length: 32, default: null, nullable: true })
+  emailHash: Buffer
+
+  @Column({ name: 'created', default: () => 'CURRENT_TIMESTAMP', nullable: false })
+  createdAt: Date
+
+  @Column({ name: 'email_checked', type: 'bool', nullable: false, default: false })
+  emailChecked: boolean
+
+  @Column({ length: 4, default: 'de', collation: 'utf8mb4_unicode_ci', nullable: false })
+  language: string
+
+  @Column({ name: 'is_admin', type: 'datetime', nullable: true, default: null })
+  isAdmin: Date | null
+
+  @Column({ name: 'referrer_id', type: 'int', unsigned: true, nullable: true, default: null })
+  referrerId?: number | null
+
+  @Column({
+    name: 'contribution_link_id',
+    type: 'int',
+    unsigned: true,
+    nullable: true,
+    default: null,
+  })
+  contributionLinkId?: number | null
+
+  @Column({ name: 'publisher_id', default: 0 })
+  publisherId: number
+
+  @Column({
+    type: 'text',
+    name: 'passphrase',
+    collation: 'utf8mb4_unicode_ci',
+    nullable: true,
+    default: null,
+  })
+  passphrase: string
+}

database/entity/User.ts

@@ -1 +1 @@
-export { User } from './0037-drop_user_setting_table/User'
+export { User } from './0040-add_contribution_link_id_to_user/User'

database/migrations/0040-add_contribution_link_id_to_user.ts

@@ -0,0 +1,14 @@
+/* MIGRATION TO ADD contribution_link_id FIELD TO users */
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export async function upgrade(queryFn: (query: string, values?: any[]) => Promise<Array<any>>) {
+  await queryFn(
+    'ALTER TABLE `users` ADD COLUMN `contribution_link_id` int UNSIGNED DEFAULT NULL AFTER `referrer_id`;',
+  )
+}
+
+export async function downgrade(queryFn: (query: string, values?: any[]) => Promise<Array<any>>) {
+  await queryFn('ALTER TABLE `users` DROP COLUMN `contribution_link_id`;')
+}