Merge remote-tracking branch 'origin/master' into

2420-feature-federation-implement-exchange-of-api-versions-persist-in-table

CONTRIBUTING.md

@@ -1,10 +1,28 @@
-# Docker More Closely
+# Contributing
 
-## Apple M1 Platform
+If you contribute to our project, please consider the following points.
+
+## Localization
+
+### Quotation Marks
+
+The following characters are different from the programming quotation mark:
+
+`"` or `\"`
+
+Please copy and paste the following quotes for the languages:
+
+- de: „Dies ist ein Beispielsatz.“
+- en: “This is a sample sentence.”
+  - See <https://grammar.collinsdictionary.com/easy-learning/when-do-you-use-quotation-marks-or-in-english>
+
+## Docker – More Closely
+
+### Apple M1 Platform
 
 ***Attention:** For using Docker commands in Apple M1 environments!*
 
-### Enviroment Variable For Apple M1 Platform
+#### Environment Variable For Apple M1 Platform
 
 To set the Docker platform environment variable in your terminal tab, run:
 
@@ -13,7 +31,7 @@ To set the Docker platform environment variable in your terminal tab, run:
 $ export DOCKER_DEFAULT_PLATFORM=linux/amd64
 ```
 
-### Docker Compose Override File For Apple M1 Platform
+#### Docker Compose Override File For Apple M1 Platform
 
 For Docker compose `up` or `build` commands, you can use our Apple M1 override file that specifies the M1 platform:
 
@@ -27,7 +45,7 @@ $ docker compose -f docker-compose.yml -f docker-compose.override.yml -f docker-
 $ docker compose -f docker-compose.yml -f docker-compose.apple-m1.override.yml up
 ```
 
-## Analysing Docker Builds
+### Analyzing Docker Builds
 
 To analyze a Docker build, there is a wonderful tool called [dive](https://github.com/wagoodman/dive). Please sponsor if you're using it!
 

backend/jest.config.js

@@ -9,9 +9,10 @@ module.exports = {
   modulePathIgnorePatterns: ['<rootDir>/build/'],
   moduleNameMapper: {
     '@/(.*)': '<rootDir>/src/$1',
-    '@model/(.*)': '<rootDir>/src/graphql/model/$1',
     '@arg/(.*)': '<rootDir>/src/graphql/arg/$1',
     '@enum/(.*)': '<rootDir>/src/graphql/enum/$1',
+    '@model/(.*)': '<rootDir>/src/graphql/model/$1',
+    '@union/(.*)': '<rootDir>/src/graphql/union/$1',
     '@repository/(.*)': '<rootDir>/src/typeorm/repository/$1',
     '@test/(.*)': '<rootDir>/test/$1',
     '@entity/(.*)':

backend/package.json

@@ -8,7 +8,7 @@
   "license": "Apache-2.0",
   "private": false,
   "scripts": {
-    "build": "tsc --build",
+    "build": "tsc --build && mkdir -p build/src/emails/templates/ && cp -r src/emails/templates/* build/src/emails/templates/ && mkdir -p build/src/locales/ && cp -r src/locales/*.json build/src/locales/",
     "clean": "tsc --build --clean",
     "start": "cross-env TZ=UTC TS_NODE_BASEURL=./build node -r tsconfig-paths/register build/src/index.js",
     "dev": "cross-env TZ=UTC nodemon -w src --ext ts --exec ts-node -r tsconfig-paths/register src/index.ts",

backend/src/config/index.ts

@@ -10,7 +10,7 @@ Decimal.set({
 })
 
 const constants = {
-  DB_VERSION: '0055-add_communities_table',
+  DB_VERSION: '0055-consistent_deleted_users',
   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/emails/accountMultiRegistration/subject.pug

@@ -1 +0,0 @@
-= t('emails.accountMultiRegistration.subject')

backend/src/emails/sendEmailTranslated.test.ts

@@ -89,7 +89,7 @@ describe('sendEmailTranslated', () => {
           originalMessage: expect.objectContaining({
             to: 'receiver@mail.org',
             cc: 'support@gradido.net',
-            from: 'Gradido (nicht antworten) <info@gradido.net>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
             attachments: [],
             subject: 'Gradido: Try To Register Again With Your Email',
             html: expect.stringContaining('Gradido: Try To Register Again With Your Email'),
@@ -107,4 +107,41 @@ describe('sendEmailTranslated', () => {
       expect(i18n.__).toBeCalled()
     })
   })
+
+  describe('with email EMAIL_TEST_MODUS true', () => {
+    beforeEach(async () => {
+      jest.clearAllMocks()
+      CONFIG.EMAIL = true
+      CONFIG.EMAIL_TEST_MODUS = true
+      result = await sendEmailTranslated({
+        receiver: {
+          to: 'receiver@mail.org',
+          cc: 'support@gradido.net',
+        },
+        template: 'accountMultiRegistration',
+        locals: {
+          locale: 'en',
+        },
+      })
+    })
+
+    it('call of "sendEmailTranslated" with faked "to"', () => {
+      expect(result).toMatchObject({
+        envelope: {
+          from: CONFIG.EMAIL_SENDER,
+          to: [CONFIG.EMAIL_TEST_RECEIVER, 'support@gradido.net'],
+        },
+        message: expect.any(String),
+        originalMessage: expect.objectContaining({
+          to: CONFIG.EMAIL_TEST_RECEIVER,
+          cc: 'support@gradido.net',
+          from: `Gradido (do not answer) <${CONFIG.EMAIL_SENDER}>`,
+          attachments: [],
+          subject: 'Gradido: Try To Register Again With Your Email',
+          html: expect.stringContaining('Gradido: Try To Register Again With Your Email'),
+          text: expect.stringContaining('GRADIDO: TRY TO REGISTER AGAIN WITH YOUR EMAIL'),
+        }),
+      })
+    })
+  })
 })

backend/src/emails/sendEmailTranslated.ts

@@ -1,18 +1,17 @@
+import CONFIG from '@/config'
 import { backendLogger as logger } from '@/server/logger'
 import path from 'path'
 import { createTransport } from 'nodemailer'
 import Email from 'email-templates'
 import i18n from 'i18n'
 
-import CONFIG from '@/config'
-
 export const sendEmailTranslated = async (params: {
   receiver: {
     to: string
     cc?: string
   }
   template: string
-  locals: Record<string, string>
+  locals: Record<string, unknown>
 }): Promise<Record<string, unknown> | null> => {
   let resultSend: Record<string, unknown> | null = null
 
@@ -32,8 +31,7 @@ export const sendEmailTranslated = async (params: {
     logger.info(`Emails are disabled via config...`)
     return null
   }
-  // because 'CONFIG.EMAIL_TEST_MODUS' can be boolean 'true' or string '`false`'
-  if (CONFIG.EMAIL_TEST_MODUS === true) {
+  if (CONFIG.EMAIL_TEST_MODUS) {
     logger.info(
       `Testmodus=ON: change receiver from ${params.receiver.to} to ${CONFIG.EMAIL_TEST_RECEIVER}`,
     )
@@ -50,12 +48,12 @@ export const sendEmailTranslated = async (params: {
     },
   })
 
-  i18n.setLocale(params.locals.locale) // for email
+  i18n.setLocale(params.locals.locale as string) // for email
 
   // TESTING: see 'README.md'
   const email = new Email({
     message: {
-      from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`,
+      from: `Gradido (${i18n.__('emails.general.doNotAnswer')}) <${CONFIG.EMAIL_SENDER}>`,
     },
     transport,
     preview: false,
@@ -65,7 +63,7 @@ export const sendEmailTranslated = async (params: {
   // ATTENTION: await is needed, because otherwise on send the email gets send in the language of the current user, because below the language gets reset
   await email
     .send({
-      template: path.join(__dirname, params.template),
+      template: path.join(__dirname, 'templates', params.template),
       message: params.receiver,
       locals: params.locals, // the 'locale' in here seems not to be used by 'email-template', because it doesn't work if the language isn't set before by 'i18n.setLocale'
     })

backend/src/emails/sendEmailVariants.test.ts

@@ -1,12 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import Decimal from 'decimal.js-light'
+import { testEnvironment } from '@test/helpers'
+import { logger, i18n as localization } from '@test/testSetup'
 import CONFIG from '@/config'
-import { sendAccountMultiRegistrationEmail } from './sendEmailVariants'
+import {
+  sendAddedContributionMessageEmail,
+  sendAccountActivationEmail,
+  sendAccountMultiRegistrationEmail,
+  sendContributionConfirmedEmail,
+  sendContributionRejectedEmail,
+  sendResetPasswordEmail,
+  sendTransactionLinkRedeemedEmail,
+  sendTransactionReceivedEmail,
+} from './sendEmailVariants'
 import { sendEmailTranslated } from './sendEmailTranslated'
 
-CONFIG.EMAIL = true
-CONFIG.EMAIL_SMTP_URL = 'EMAIL_SMTP_URL'
-CONFIG.EMAIL_SMTP_PORT = '1234'
-CONFIG.EMAIL_USERNAME = 'user'
-CONFIG.EMAIL_PASSWORD = 'pwd'
+let con: any
+let testEnv: any
+
+beforeAll(async () => {
+  testEnv = await testEnvironment(logger, localization)
+  con = testEnv.con
+  // await cleanDB()
+})
+
+afterAll(async () => {
+  // await cleanDB()
+  await con.close()
+})
 
 jest.mock('./sendEmailTranslated', () => {
   const originalModule = jest.requireActual('./sendEmailTranslated')
@@ -17,7 +39,154 @@ jest.mock('./sendEmailTranslated', () => {
 })
 
 describe('sendEmailVariants', () => {
-  let result: Record<string, unknown> | null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let result: any
+
+  describe('sendAddedContributionMessageEmail', () => {
+    beforeAll(async () => {
+      result = await sendAddedContributionMessageEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        senderFirstName: 'Bibi',
+        senderLastName: 'Bloxberg',
+        contributionMemo: 'My contribution.',
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'addedContributionMessage',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            senderFirstName: 'Bibi',
+            senderLastName: 'Bloxberg',
+            contributionMemo: 'My contribution.',
+            overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Message about your common good contribution',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: MESSAGE ABOUT YOUR COMMON GOOD CONTRIBUTION'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: Message about your common good contribution</title>',
+        )
+        expect(result.originalMessage.html).toContain(
+          '>Gradido: Message about your common good contribution</h1>',
+        )
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'you have received a message from Bibi Bloxberg regarding your common good contribution “My contribution.”.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'To view and reply to the message, go to the “Community” menu in your Gradido account and click on the “My contributions to the common good” tab!',
+        )
+        expect(result.originalMessage.html).toContain(
+          `Link to your account:<span> </span><a href="${CONFIG.EMAIL_LINK_OVERVIEW}">${CONFIG.EMAIL_LINK_OVERVIEW}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Please do not reply to this email!')
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendAccountActivationEmail', () => {
+    beforeAll(async () => {
+      result = await sendAccountActivationEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        activationLink: 'http://localhost/checkEmail/6627633878930542284',
+        timeDurationObject: { hours: 23, minutes: 30 },
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'accountActivation',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            activationLink: 'http://localhost/checkEmail/6627633878930542284',
+            timeDurationObject: { hours: 23, minutes: 30 },
+            resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Email Verification',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: EMAIL VERIFICATION'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain('<title>Gradido: Email Verification</title>')
+        expect(result.originalMessage.html).toContain('>Gradido: Email Verification</h1>')
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'Your email address has just been registered with Gradido.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'Please click on this link to complete the registration and activate your Gradido account:',
+        )
+        expect(result.originalMessage.html).toContain(
+          '<a href="http://localhost/checkEmail/6627633878930542284">http://localhost/checkEmail/6627633878930542284</a>',
+        )
+        expect(result.originalMessage.html).toContain(
+          'or copy the link above into your browser window.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'The link has a validity of 23 hours and 30 minutes. If the validity of the link has already expired, you can have a new link sent to you here by entering your email address:',
+        )
+        expect(result.originalMessage.html).toContain(
+          `<a href="${CONFIG.EMAIL_LINK_FORGOTPASSWORD}">${CONFIG.EMAIL_LINK_FORGOTPASSWORD}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
 
   describe('sendAccountMultiRegistrationEmail', () => {
     beforeAll(async () => {
@@ -54,34 +223,401 @@ describe('sendEmailVariants', () => {
           message: expect.any(String),
           originalMessage: expect.objectContaining({
             to: 'Peter Lustig <peter@lustig.de>',
-            from: 'Gradido (nicht antworten) <info@gradido.net>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
             attachments: [],
             subject: 'Gradido: Try To Register Again With Your Email',
-            html:
-              expect.stringContaining(
-                '<title>Gradido: Try To Register Again With Your Email</title>',
-              ) &&
-              expect.stringContaining('>Gradido: Try To Register Again With Your Email</h1>') &&
-              expect.stringContaining(
-                'Your email address has just been used again to register an account with Gradido.',
-              ) &&
-              expect.stringContaining(
-                'However, an account already exists for your email address.',
-              ) &&
-              expect.stringContaining(
-                'Please click on the following link if you have forgotten your password:',
-              ) &&
-              expect.stringContaining(
-                `<a href="${CONFIG.EMAIL_LINK_FORGOTPASSWORD}">${CONFIG.EMAIL_LINK_FORGOTPASSWORD}</a>`,
-              ) &&
-              expect.stringContaining('or copy the link above into your browser window.') &&
-              expect.stringContaining(
-                'If you are not the one who tried to register again, please contact our support:',
-              ) &&
-              expect.stringContaining('Sincerely yours,<br><span>your Gradido team'),
+            html: expect.any(String),
             text: expect.stringContaining('GRADIDO: TRY TO REGISTER AGAIN WITH YOUR EMAIL'),
           }),
         })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: Try To Register Again With Your Email</title>',
+        )
+        expect(result.originalMessage.html).toContain(
+          '>Gradido: Try To Register Again With Your Email</h1>',
+        )
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'Your email address has just been used again to register an account with Gradido.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'However, an account already exists for your email address.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'Please click on the following link if you have forgotten your password:',
+        )
+        expect(result.originalMessage.html).toContain(
+          `<a href="${CONFIG.EMAIL_LINK_FORGOTPASSWORD}">${CONFIG.EMAIL_LINK_FORGOTPASSWORD}</a>`,
+        )
+        expect(result.originalMessage.html).toContain(
+          'or copy the link above into your browser window.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'If you are not the one who tried to register again, please contact our support:',
+        )
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendContributionConfirmedEmail', () => {
+    beforeAll(async () => {
+      result = await sendContributionConfirmedEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        senderFirstName: 'Bibi',
+        senderLastName: 'Bloxberg',
+        contributionMemo: 'My contribution.',
+        contributionAmount: new Decimal(23.54),
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'contributionConfirmed',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            senderFirstName: 'Bibi',
+            senderLastName: 'Bloxberg',
+            contributionMemo: 'My contribution.',
+            contributionAmount: '23.54',
+            overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Your common good contribution was confirmed',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: YOUR COMMON GOOD CONTRIBUTION WAS CONFIRMED'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: Your common good contribution was confirmed</title>',
+        )
+        expect(result.originalMessage.html).toContain(
+          '>Gradido: Your common good contribution was confirmed</h1>',
+        )
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'Your public good contribution “My contribution.” has just been confirmed by Bibi Bloxberg and credited to your Gradido account.',
+        )
+        expect(result.originalMessage.html).toContain('Amount: 23.54 GDD')
+        expect(result.originalMessage.html).toContain(
+          `Link to your account:<span> </span><a href="${CONFIG.EMAIL_LINK_OVERVIEW}">${CONFIG.EMAIL_LINK_OVERVIEW}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Please do not reply to this email!')
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendContributionRejectedEmail', () => {
+    beforeAll(async () => {
+      result = await sendContributionRejectedEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        senderFirstName: 'Bibi',
+        senderLastName: 'Bloxberg',
+        contributionMemo: 'My contribution.',
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'contributionRejected',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            senderFirstName: 'Bibi',
+            senderLastName: 'Bloxberg',
+            contributionMemo: 'My contribution.',
+            overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Your common good contribution was rejected',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: YOUR COMMON GOOD CONTRIBUTION WAS REJECTED'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: Your common good contribution was rejected</title>',
+        )
+        expect(result.originalMessage.html).toContain(
+          '>Gradido: Your common good contribution was rejected</h1>',
+        )
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'Your public good contribution “My contribution.” was rejected by Bibi Bloxberg.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'To see your common good contributions and related messages, go to the “Community” menu in your Gradido account and click on the “My contributions to the common good” tab!',
+        )
+        expect(result.originalMessage.html).toContain(
+          `Link to your account:<span> </span><a href="${CONFIG.EMAIL_LINK_OVERVIEW}">${CONFIG.EMAIL_LINK_OVERVIEW}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Please do not reply to this email!')
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendResetPasswordEmail', () => {
+    beforeAll(async () => {
+      result = await sendResetPasswordEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        resetLink: 'http://localhost/reset-password/3762660021544901417',
+        timeDurationObject: { hours: 23, minutes: 30 },
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'resetPassword',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            resetLink: 'http://localhost/reset-password/3762660021544901417',
+            timeDurationObject: { hours: 23, minutes: 30 },
+            resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Reset password',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: RESET PASSWORD'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain('<title>Gradido: Reset password</title>')
+        expect(result.originalMessage.html).toContain('>Gradido: Reset password</h1>')
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'You, or someone else, requested a password reset for this account.',
+        )
+        expect(result.originalMessage.html).toContain('If it was you, please click on the link:')
+        expect(result.originalMessage.html).toContain(
+          '<a href="http://localhost/reset-password/3762660021544901417">http://localhost/reset-password/3762660021544901417</a>',
+        )
+        expect(result.originalMessage.html).toContain(
+          'or copy the link above into your browser window.',
+        )
+        expect(result.originalMessage.html).toContain(
+          'The link has a validity of 23 hours and 30 minutes. If the validity of the link has already expired, you can have a new link sent to you here by entering your email address:',
+        )
+        expect(result.originalMessage.html).toContain(
+          `<a href="${CONFIG.EMAIL_LINK_FORGOTPASSWORD}">${CONFIG.EMAIL_LINK_FORGOTPASSWORD}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendTransactionLinkRedeemedEmail', () => {
+    beforeAll(async () => {
+      result = await sendTransactionLinkRedeemedEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        senderFirstName: 'Bibi',
+        senderLastName: 'Bloxberg',
+        senderEmail: 'bibi@bloxberg.de',
+        transactionMemo: 'You deserve it! 🙏🏼',
+        transactionAmount: new Decimal(17.65),
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'transactionLinkRedeemed',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            senderFirstName: 'Bibi',
+            senderLastName: 'Bloxberg',
+            senderEmail: 'bibi@bloxberg.de',
+            transactionMemo: 'You deserve it! 🙏🏼',
+            transactionAmount: '17.65',
+            overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: Your Gradido link has been redeemed',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: YOUR GRADIDO LINK HAS BEEN REDEEMED'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: Your Gradido link has been redeemed</title>',
+        )
+        expect(result.originalMessage.html).toContain(
+          '>Gradido: Your Gradido link has been redeemed</h1>',
+        )
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'Bibi Bloxberg (bibi@bloxberg.de) has just redeemed your link.',
+        )
+        expect(result.originalMessage.html).toContain('Amount: 17.65 GDD')
+        expect(result.originalMessage.html).toContain('Memo: You deserve it! 🙏🏼')
+        expect(result.originalMessage.html).toContain(
+          `You can find transaction details in your Gradido account:<span> </span><a href="${CONFIG.EMAIL_LINK_OVERVIEW}">${CONFIG.EMAIL_LINK_OVERVIEW}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Please do not reply to this email!')
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
+      })
+    })
+  })
+
+  describe('sendTransactionReceivedEmail', () => {
+    beforeAll(async () => {
+      result = await sendTransactionReceivedEmail({
+        firstName: 'Peter',
+        lastName: 'Lustig',
+        email: 'peter@lustig.de',
+        language: 'en',
+        senderFirstName: 'Bibi',
+        senderLastName: 'Bloxberg',
+        senderEmail: 'bibi@bloxberg.de',
+        transactionAmount: new Decimal(37.4),
+      })
+    })
+
+    describe('calls "sendEmailTranslated"', () => {
+      it('with expected parameters', () => {
+        expect(sendEmailTranslated).toBeCalledWith({
+          receiver: {
+            to: 'Peter Lustig <peter@lustig.de>',
+          },
+          template: 'transactionReceived',
+          locals: {
+            firstName: 'Peter',
+            lastName: 'Lustig',
+            locale: 'en',
+            senderFirstName: 'Bibi',
+            senderLastName: 'Bloxberg',
+            senderEmail: 'bibi@bloxberg.de',
+            transactionAmount: '37.40',
+            overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+          },
+        })
+      })
+
+      it('has expected result', () => {
+        expect(result).toMatchObject({
+          envelope: {
+            from: 'info@gradido.net',
+            to: ['peter@lustig.de'],
+          },
+          message: expect.any(String),
+          originalMessage: expect.objectContaining({
+            to: 'Peter Lustig <peter@lustig.de>',
+            from: 'Gradido (do not answer) <info@gradido.net>',
+            attachments: [],
+            subject: 'Gradido: You have received Gradidos',
+            html: expect.any(String),
+            text: expect.stringContaining('GRADIDO: YOU HAVE RECEIVED GRADIDOS'),
+          }),
+        })
+        expect(result.originalMessage.html).toContain('<!DOCTYPE html>')
+        expect(result.originalMessage.html).toContain('<html lang="en">')
+        expect(result.originalMessage.html).toContain(
+          '<title>Gradido: You have received Gradidos</title>',
+        )
+        expect(result.originalMessage.html).toContain('>Gradido: You have received Gradidos</h1>')
+        expect(result.originalMessage.html).toContain('Hello Peter Lustig')
+        expect(result.originalMessage.html).toContain(
+          'You have just received 37.40 GDD from Bibi Bloxberg (bibi@bloxberg.de).',
+        )
+        expect(result.originalMessage.html).toContain(
+          `You can find transaction details in your Gradido account:<span> </span><a href="${CONFIG.EMAIL_LINK_OVERVIEW}">${CONFIG.EMAIL_LINK_OVERVIEW}</a>`,
+        )
+        expect(result.originalMessage.html).toContain('Please do not reply to this email!')
+        expect(result.originalMessage.html).toContain('Kind regards,<br><span>your Gradido team')
       })
     })
   })

backend/src/emails/sendEmailVariants.ts

@@ -1,6 +1,56 @@
+import Decimal from 'decimal.js-light'
 import CONFIG from '@/config'
+import { decimalSeparatorByLanguage } from '@/util/utilities'
 import { sendEmailTranslated } from './sendEmailTranslated'
 
+export const sendAddedContributionMessageEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  senderFirstName: string
+  senderLastName: string
+  contributionMemo: string
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: {
+      to: `${data.firstName} ${data.lastName} <${data.email}>`,
+    },
+    template: 'addedContributionMessage',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      senderFirstName: data.senderFirstName,
+      senderLastName: data.senderLastName,
+      contributionMemo: data.contributionMemo,
+      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    },
+  })
+}
+
+export const sendAccountActivationEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  activationLink: string
+  timeDurationObject: Record<string, unknown>
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'accountActivation',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      activationLink: data.activationLink,
+      timeDurationObject: data.timeDurationObject,
+      resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD,
+    },
+  })
+}
+
 export const sendAccountMultiRegistrationEmail = (data: {
   firstName: string
   lastName: string
@@ -11,10 +61,136 @@ export const sendAccountMultiRegistrationEmail = (data: {
     receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
     template: 'accountMultiRegistration',
     locals: {
-      locale: data.language,
       firstName: data.firstName,
       lastName: data.lastName,
+      locale: data.language,
       resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD,
     },
   })
 }
+
+export const sendContributionConfirmedEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  senderFirstName: string
+  senderLastName: string
+  contributionMemo: string
+  contributionAmount: Decimal
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'contributionConfirmed',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      senderFirstName: data.senderFirstName,
+      senderLastName: data.senderLastName,
+      contributionMemo: data.contributionMemo,
+      contributionAmount: decimalSeparatorByLanguage(data.contributionAmount, data.language),
+      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    },
+  })
+}
+
+export const sendContributionRejectedEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  senderFirstName: string
+  senderLastName: string
+  contributionMemo: string
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'contributionRejected',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      senderFirstName: data.senderFirstName,
+      senderLastName: data.senderLastName,
+      contributionMemo: data.contributionMemo,
+      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    },
+  })
+}
+
+export const sendResetPasswordEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  resetLink: string
+  timeDurationObject: Record<string, unknown>
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'resetPassword',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      resetLink: data.resetLink,
+      timeDurationObject: data.timeDurationObject,
+      resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD,
+    },
+  })
+}
+
+export const sendTransactionLinkRedeemedEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  senderFirstName: string
+  senderLastName: string
+  senderEmail: string
+  transactionMemo: string
+  transactionAmount: Decimal
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'transactionLinkRedeemed',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      senderFirstName: data.senderFirstName,
+      senderLastName: data.senderLastName,
+      senderEmail: data.senderEmail,
+      transactionMemo: data.transactionMemo,
+      transactionAmount: decimalSeparatorByLanguage(data.transactionAmount, data.language),
+      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    },
+  })
+}
+
+export const sendTransactionReceivedEmail = (data: {
+  firstName: string
+  lastName: string
+  email: string
+  language: string
+  senderFirstName: string
+  senderLastName: string
+  senderEmail: string
+  transactionAmount: Decimal
+}): Promise<Record<string, unknown> | null> => {
+  return sendEmailTranslated({
+    receiver: { to: `${data.firstName} ${data.lastName} <${data.email}>` },
+    template: 'transactionReceived',
+    locals: {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      locale: data.language,
+      senderFirstName: data.senderFirstName,
+      senderLastName: data.senderLastName,
+      senderEmail: data.senderEmail,
+      transactionAmount: decimalSeparatorByLanguage(data.transactionAmount, data.language),
+      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    },
+  })
+}

backend/src/emails/templates/accountActivation/html.pug

@@ -0,0 +1,20 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.accountActivation.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.accountActivation.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.accountActivation.emailRegistered')
+      p= t('emails.accountActivation.pleaseClickLink')
+        br
+        a(href=activationLink) #{activationLink}
+        br
+        span= t('emails.general.orCopyLink')
+      p= t('emails.accountActivation.duration', { hours: timeDurationObject.hours, minutes: timeDurationObject.minutes })
+        br
+        a(href=resendLink) #{resendLink}
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/accountActivation/subject.pug

@@ -0,0 +1 @@
+= t('emails.accountActivation.subject')

backend/src/emails/templates/accountMultiRegistration/html.pug

@@ -5,7 +5,7 @@ html(lang=locale)
   body
     h1(style='margin-bottom: 24px;')= t('emails.accountMultiRegistration.subject')
     #container.col
-      p(style='margin-bottom: 24px;')= t('emails.accountMultiRegistration.helloName', { firstName, lastName })
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
       p= t('emails.accountMultiRegistration.emailReused')
         br
         span= t('emails.accountMultiRegistration.emailExists')
@@ -17,6 +17,6 @@ html(lang=locale)
       p= t('emails.accountMultiRegistration.ifYouAreNotTheOne')
         br
         a(href='https://gradido.net/de/contact/') https://gradido.net/de/contact/
-      p(style='margin-top: 24px;')= t('emails.accountMultiRegistration.sincerelyYours')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
         br
-        span= t('emails.accountMultiRegistration.yourGradidoTeam')
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/accountMultiRegistration/subject.pug

@@ -0,0 +1 @@
+= t('emails.accountMultiRegistration.subject')

backend/src/emails/templates/addedContributionMessage/html.pug

@@ -0,0 +1,17 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.addedContributionMessage.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.addedContributionMessage.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.addedContributionMessage.commonGoodContributionMessage', { senderFirstName, senderLastName, contributionMemo })
+      p= t('emails.addedContributionMessage.toSeeAndAnswerMessage')
+      p= t('emails.general.linkToYourAccount')
+        span= " "
+        a(href=overviewURL) #{overviewURL}
+      p= t('emails.general.pleaseDoNotReply')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/addedContributionMessage/subject.pug

@@ -0,0 +1 @@
+= t('emails.addedContributionMessage.subject')

backend/src/emails/templates/contributionConfirmed/html.pug

@@ -0,0 +1,17 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.contributionConfirmed.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.contributionConfirmed.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.contributionConfirmed.commonGoodContributionConfirmed', { senderFirstName, senderLastName, contributionMemo })
+      p= t('emails.general.amountGDD', { amountGDD: contributionAmount })
+      p= t('emails.general.linkToYourAccount')
+        span= " "
+        a(href=overviewURL) #{overviewURL}
+      p= t('emails.general.pleaseDoNotReply')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/contributionConfirmed/subject.pug

@@ -0,0 +1 @@
+= t('emails.contributionConfirmed.subject')

backend/src/emails/templates/contributionRejected/html.pug

@@ -0,0 +1,17 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.contributionRejected.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.contributionRejected.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.contributionRejected.commonGoodContributionRejected', { senderFirstName, senderLastName, contributionMemo })
+      p= t('emails.contributionRejected.toSeeContributionsAndMessages')
+      p= t('emails.general.linkToYourAccount')
+        span= " "
+        a(href=overviewURL) #{overviewURL}
+      p= t('emails.general.pleaseDoNotReply')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/contributionRejected/subject.pug

@@ -0,0 +1 @@
+= t('emails.contributionRejected.subject')

backend/src/emails/templates/resetPassword/html.pug

@@ -0,0 +1,20 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.resetPassword.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.resetPassword.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.resetPassword.youOrSomeoneResetPassword')
+      p= t('emails.resetPassword.pleaseClickLink')
+        br
+        a(href=resetLink) #{resetLink}
+        br
+        span= t('emails.general.orCopyLink')
+      p= t('emails.resetPassword.duration', { hours: timeDurationObject.hours, minutes: timeDurationObject.minutes })
+        br
+        a(href=resendLink) #{resendLink}
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/resetPassword/subject.pug

@@ -0,0 +1 @@
+= t('emails.resetPassword.subject')

backend/src/emails/templates/transactionLinkRedeemed/html.pug

@@ -0,0 +1,19 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.transactionLinkRedeemed.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.transactionLinkRedeemed.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.transactionLinkRedeemed.hasRedeemedYourLink', { senderFirstName, senderLastName, senderEmail })
+      p= t('emails.general.amountGDD', { amountGDD: transactionAmount })
+        br
+        span= t('emails.transactionLinkRedeemed.memo', { transactionMemo })
+      p= t('emails.general.detailsYouFindOnLinkToYourAccount')
+        span= " "
+        a(href=overviewURL) #{overviewURL}
+      p= t('emails.general.pleaseDoNotReply')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/transactionLinkRedeemed/subject.pug

@@ -0,0 +1 @@
+= t('emails.transactionLinkRedeemed.subject')

backend/src/emails/templates/transactionReceived/html.pug

@@ -0,0 +1,16 @@
+doctype html
+html(lang=locale)
+  head
+    title= t('emails.transactionReceived.subject')
+  body
+    h1(style='margin-bottom: 24px;')= t('emails.transactionReceived.subject')
+    #container.col
+      p(style='margin-bottom: 24px;')= t('emails.general.helloName', { firstName, lastName })
+      p= t('emails.transactionReceived.haveReceivedAmountGDDFrom', { transactionAmount, senderFirstName, senderLastName, senderEmail })
+      p= t('emails.general.detailsYouFindOnLinkToYourAccount')
+        span= " "
+        a(href=overviewURL) #{overviewURL}
+      p= t('emails.general.pleaseDoNotReply')
+      p(style='margin-top: 24px;')= t('emails.general.sincerelyYours')
+        br
+        span= t('emails.general.yourGradidoTeam')

backend/src/emails/templates/transactionReceived/subject.pug

@@ -0,0 +1 @@
+= t('emails.transactionReceived.subject')

backend/src/graphql/resolver/AdminResolver.ts

@@ -1,918 +0,0 @@
-import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
-import { backendLogger as logger } from '@/server/logger'
-import { Resolver, Query, Arg, Args, Authorized, Mutation, Ctx, Int } from 'type-graphql'
-import {
-  getCustomRepository,
-  IsNull,
-  getConnection,
-  In,
-  MoreThan,
-  FindOperator,
-} from '@dbTools/typeorm'
-import { UserAdmin, SearchUsersResult } from '@model/UserAdmin'
-import { UnconfirmedContribution } from '@model/UnconfirmedContribution'
-import { AdminCreateContributions } from '@model/AdminCreateContributions'
-import { AdminUpdateContribution } from '@model/AdminUpdateContribution'
-import { ContributionLink } from '@model/ContributionLink'
-import { ContributionLinkList } from '@model/ContributionLinkList'
-import { Contribution } from '@model/Contribution'
-import { RIGHTS } from '@/auth/RIGHTS'
-import { UserRepository } from '@repository/User'
-import AdminCreateContributionArgs from '@arg/AdminCreateContributionArgs'
-import AdminUpdateContributionArgs from '@arg/AdminUpdateContributionArgs'
-import SearchUsersArgs from '@arg/SearchUsersArgs'
-import ContributionLinkArgs from '@arg/ContributionLinkArgs'
-import { Transaction as DbTransaction } from '@entity/Transaction'
-import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
-import { TransactionLink, TransactionLinkResult } from '@model/TransactionLink'
-import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
-import { calculateDecay } from '@/util/decay'
-import { Contribution as DbContribution } from '@entity/Contribution'
-import { hasElopageBuys } from '@/util/hasElopageBuys'
-import { User as dbUser } from '@entity/User'
-import { User } from '@model/User'
-import { TransactionTypeId } from '@enum/TransactionTypeId'
-import { ContributionType } from '@enum/ContributionType'
-import { ContributionStatus } from '@enum/ContributionStatus'
-import Decimal from 'decimal.js-light'
-import { Decay } from '@model/Decay'
-import Paginated from '@arg/Paginated'
-import TransactionLinkFilters from '@arg/TransactionLinkFilters'
-import { Order } from '@enum/Order'
-import { findUserByEmail, activationLink, printTimeDuration } from './UserResolver'
-import { sendAccountActivationEmail } from '@/mailer/sendAccountActivationEmail'
-import { transactionLinkCode as contributionLinkCode } from './TransactionLinkResolver'
-import CONFIG from '@/config'
-import {
-  getUserCreation,
-  getUserCreations,
-  validateContribution,
-  isStartEndDateValid,
-  updateCreations,
-  isValidDateString,
-} from './util/creations'
-import {
-  CONTRIBUTIONLINK_NAME_MAX_CHARS,
-  CONTRIBUTIONLINK_NAME_MIN_CHARS,
-  FULL_CREATION_AVAILABLE,
-  MEMO_MAX_CHARS,
-  MEMO_MIN_CHARS,
-} from './const/const'
-import { UserContact } from '@entity/UserContact'
-import { ContributionMessage as DbContributionMessage } from '@entity/ContributionMessage'
-import ContributionMessageArgs from '@arg/ContributionMessageArgs'
-import { ContributionMessageType } from '@enum/MessageType'
-import { ContributionMessage } from '@model/ContributionMessage'
-import { sendContributionConfirmedEmail } from '@/mailer/sendContributionConfirmedEmail'
-import { sendContributionRejectedEmail } from '@/mailer/sendContributionRejectedEmail'
-import { sendAddedContributionMessageEmail } from '@/mailer/sendAddedContributionMessageEmail'
-import { eventProtocol } from '@/event/EventProtocolEmitter'
-import {
-  Event,
-  EventAdminContributionCreate,
-  EventAdminContributionDelete,
-  EventAdminContributionUpdate,
-  EventContributionConfirm,
-  EventSendConfirmationEmail,
-} from '@/event/Event'
-import { ContributionListResult } from '../model/Contribution'
-
-// const EMAIL_OPT_IN_REGISTER = 1
-// const EMAIL_OPT_UNKNOWN = 3 // elopage?
-
-@Resolver()
-export class AdminResolver {
-  @Authorized([RIGHTS.SEARCH_USERS])
-  @Query(() => SearchUsersResult)
-  async searchUsers(
-    @Args()
-    { searchText, currentPage = 1, pageSize = 25, filters }: SearchUsersArgs,
-    @Ctx() context: Context,
-  ): Promise<SearchUsersResult> {
-    const clientTimezoneOffset = getClientTimezoneOffset(context)
-    const userRepository = getCustomRepository(UserRepository)
-    const userFields = [
-      'id',
-      'firstName',
-      'lastName',
-      'emailId',
-      'emailContact',
-      'deletedAt',
-      'isAdmin',
-    ]
-    const [users, count] = await userRepository.findBySearchCriteriaPagedFiltered(
-      userFields.map((fieldName) => {
-        return 'user.' + fieldName
-      }),
-      searchText,
-      filters,
-      currentPage,
-      pageSize,
-    )
-
-    if (users.length === 0) {
-      return {
-        userCount: 0,
-        userList: [],
-      }
-    }
-
-    const creations = await getUserCreations(
-      users.map((u) => u.id),
-      clientTimezoneOffset,
-    )
-
-    const adminUsers = await Promise.all(
-      users.map(async (user) => {
-        let emailConfirmationSend = ''
-        if (!user.emailContact.emailChecked) {
-          if (user.emailContact.updatedAt) {
-            emailConfirmationSend = user.emailContact.updatedAt.toISOString()
-          } else {
-            emailConfirmationSend = user.emailContact.createdAt.toISOString()
-          }
-        }
-        const userCreations = creations.find((c) => c.id === user.id)
-        const adminUser = new UserAdmin(
-          user,
-          userCreations ? userCreations.creations : FULL_CREATION_AVAILABLE,
-          await hasElopageBuys(user.emailContact.email),
-          emailConfirmationSend,
-        )
-        return adminUser
-      }),
-    )
-    return {
-      userCount: count,
-      userList: adminUsers,
-    }
-  }
-
-  @Authorized([RIGHTS.SET_USER_ROLE])
-  @Mutation(() => Date, { nullable: true })
-  async setUserRole(
-    @Arg('userId', () => Int)
-    userId: number,
-    @Arg('isAdmin', () => Boolean)
-    isAdmin: boolean,
-    @Ctx()
-    context: Context,
-  ): Promise<Date | null> {
-    const user = await dbUser.findOne({ id: userId })
-    // user exists ?
-    if (!user) {
-      logger.error(`Could not find user with userId: ${userId}`)
-      throw new Error(`Could not find user with userId: ${userId}`)
-    }
-    // administrator user changes own role?
-    const moderatorUser = getUser(context)
-    if (moderatorUser.id === userId) {
-      logger.error('Administrator can not change his own role!')
-      throw new Error('Administrator can not change his own role!')
-    }
-    // change isAdmin
-    switch (user.isAdmin) {
-      case null:
-        if (isAdmin === true) {
-          user.isAdmin = new Date()
-        } else {
-          logger.error('User is already a usual user!')
-          throw new Error('User is already a usual user!')
-        }
-        break
-      default:
-        if (isAdmin === false) {
-          user.isAdmin = null
-        } else {
-          logger.error('User is already admin!')
-          throw new Error('User is already admin!')
-        }
-        break
-    }
-    await user.save()
-    const newUser = await dbUser.findOne({ id: userId })
-    return newUser ? newUser.isAdmin : null
-  }
-
-  @Authorized([RIGHTS.DELETE_USER])
-  @Mutation(() => Date, { nullable: true })
-  async deleteUser(
-    @Arg('userId', () => Int) userId: number,
-    @Ctx() context: Context,
-  ): Promise<Date | null> {
-    const user = await dbUser.findOne({ id: userId })
-    // user exists ?
-    if (!user) {
-      logger.error(`Could not find user with userId: ${userId}`)
-      throw new Error(`Could not find user with userId: ${userId}`)
-    }
-    // moderator user disabled own account?
-    const moderatorUser = getUser(context)
-    if (moderatorUser.id === userId) {
-      logger.error('Moderator can not delete his own account!')
-      throw new Error('Moderator can not delete his own account!')
-    }
-    // soft-delete user
-    await user.softRemove()
-    const newUser = await dbUser.findOne({ id: userId }, { withDeleted: true })
-    return newUser ? newUser.deletedAt : null
-  }
-
-  @Authorized([RIGHTS.UNDELETE_USER])
-  @Mutation(() => Date, { nullable: true })
-  async unDeleteUser(@Arg('userId', () => Int) userId: number): Promise<Date | null> {
-    const user = await dbUser.findOne({ id: userId }, { withDeleted: true })
-    if (!user) {
-      logger.error(`Could not find user with userId: ${userId}`)
-      throw new Error(`Could not find user with userId: ${userId}`)
-    }
-    if (!user.deletedAt) {
-      logger.error('User is not deleted')
-      throw new Error('User is not deleted')
-    }
-    await user.recover()
-    return null
-  }
-
-  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTION])
-  @Mutation(() => [Number])
-  async adminCreateContribution(
-    @Args() { email, amount, memo, creationDate }: AdminCreateContributionArgs,
-    @Ctx() context: Context,
-  ): Promise<Decimal[]> {
-    logger.info(
-      `adminCreateContribution(email=${email}, amount=${amount}, memo=${memo}, creationDate=${creationDate})`,
-    )
-    const clientTimezoneOffset = getClientTimezoneOffset(context)
-    if (!isValidDateString(creationDate)) {
-      logger.error(`invalid Date for creationDate=${creationDate}`)
-      throw new Error(`invalid Date for creationDate=${creationDate}`)
-    }
-    const emailContact = await UserContact.findOne({
-      where: { email },
-      withDeleted: true,
-      relations: ['user'],
-    })
-    if (!emailContact) {
-      logger.error(`Could not find user with email: ${email}`)
-      throw new Error(`Could not find user with email: ${email}`)
-    }
-    if (emailContact.deletedAt) {
-      logger.error('This emailContact was deleted. Cannot create a contribution.')
-      throw new Error('This emailContact was deleted. Cannot create a contribution.')
-    }
-    if (emailContact.user.deletedAt) {
-      logger.error('This user was deleted. Cannot create a contribution.')
-      throw new Error('This user was deleted. Cannot create a contribution.')
-    }
-    if (!emailContact.emailChecked) {
-      logger.error('Contribution could not be saved, Email is not activated')
-      throw new Error('Contribution could not be saved, Email is not activated')
-    }
-
-    const event = new Event()
-    const moderator = getUser(context)
-    logger.trace('moderator: ', moderator.id)
-    const creations = await getUserCreation(emailContact.userId, clientTimezoneOffset)
-    logger.trace('creations:', creations)
-    const creationDateObj = new Date(creationDate)
-    logger.trace('creationDateObj:', creationDateObj)
-    validateContribution(creations, amount, creationDateObj, clientTimezoneOffset)
-    const contribution = DbContribution.create()
-    contribution.userId = emailContact.userId
-    contribution.amount = amount
-    contribution.createdAt = new Date()
-    contribution.contributionDate = creationDateObj
-    contribution.memo = memo
-    contribution.moderatorId = moderator.id
-    contribution.contributionType = ContributionType.ADMIN
-    contribution.contributionStatus = ContributionStatus.PENDING
-
-    logger.trace('contribution to save', contribution)
-
-    await DbContribution.save(contribution)
-
-    const eventAdminCreateContribution = new EventAdminContributionCreate()
-    eventAdminCreateContribution.userId = moderator.id
-    eventAdminCreateContribution.amount = amount
-    eventAdminCreateContribution.contributionId = contribution.id
-    await eventProtocol.writeEvent(
-      event.setEventAdminContributionCreate(eventAdminCreateContribution),
-    )
-
-    return getUserCreation(emailContact.userId, clientTimezoneOffset)
-  }
-
-  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTIONS])
-  @Mutation(() => AdminCreateContributions)
-  async adminCreateContributions(
-    @Arg('pendingCreations', () => [AdminCreateContributionArgs])
-    contributions: AdminCreateContributionArgs[],
-    @Ctx() context: Context,
-  ): Promise<AdminCreateContributions> {
-    let success = false
-    const successfulContribution: string[] = []
-    const failedContribution: string[] = []
-    for (const contribution of contributions) {
-      await this.adminCreateContribution(contribution, context)
-        .then(() => {
-          successfulContribution.push(contribution.email)
-          success = true
-        })
-        .catch(() => {
-          failedContribution.push(contribution.email)
-        })
-    }
-    return {
-      success,
-      successfulContribution,
-      failedContribution,
-    }
-  }
-
-  @Authorized([RIGHTS.ADMIN_UPDATE_CONTRIBUTION])
-  @Mutation(() => AdminUpdateContribution)
-  async adminUpdateContribution(
-    @Args() { id, email, amount, memo, creationDate }: AdminUpdateContributionArgs,
-    @Ctx() context: Context,
-  ): Promise<AdminUpdateContribution> {
-    const clientTimezoneOffset = getClientTimezoneOffset(context)
-    const emailContact = await UserContact.findOne({
-      where: { email },
-      withDeleted: true,
-      relations: ['user'],
-    })
-    if (!emailContact) {
-      logger.error(`Could not find UserContact with email: ${email}`)
-      throw new Error(`Could not find UserContact with email: ${email}`)
-    }
-    const user = emailContact.user
-    if (!user) {
-      logger.error(`Could not find User to emailContact: ${email}`)
-      throw new Error(`Could not find User to emailContact: ${email}`)
-    }
-    if (user.deletedAt) {
-      logger.error(`User was deleted (${email})`)
-      throw new Error(`User was deleted (${email})`)
-    }
-
-    const moderator = getUser(context)
-
-    const contributionToUpdate = await DbContribution.findOne({
-      where: { id, confirmedAt: IsNull() },
-    })
-    if (!contributionToUpdate) {
-      logger.error('No contribution found to given id.')
-      throw new Error('No contribution found to given id.')
-    }
-
-    if (contributionToUpdate.userId !== user.id) {
-      logger.error('user of the pending contribution and send user does not correspond')
-      throw new Error('user of the pending contribution and send user does not correspond')
-    }
-
-    if (contributionToUpdate.moderatorId === null) {
-      logger.error('An admin is not allowed to update a user contribution.')
-      throw new Error('An admin is not allowed to update a user contribution.')
-    }
-
-    const creationDateObj = new Date(creationDate)
-    let creations = await getUserCreation(user.id, clientTimezoneOffset)
-
-    if (contributionToUpdate.contributionDate.getMonth() === creationDateObj.getMonth()) {
-      creations = updateCreations(creations, contributionToUpdate, clientTimezoneOffset)
-    } else {
-      logger.error('Currently the month of the contribution cannot change.')
-      throw new Error('Currently the month of the contribution cannot change.')
-    }
-
-    // all possible cases not to be true are thrown in this function
-    validateContribution(creations, amount, creationDateObj, clientTimezoneOffset)
-    contributionToUpdate.amount = amount
-    contributionToUpdate.memo = memo
-    contributionToUpdate.contributionDate = new Date(creationDate)
-    contributionToUpdate.moderatorId = moderator.id
-    contributionToUpdate.contributionStatus = ContributionStatus.PENDING
-
-    await DbContribution.save(contributionToUpdate)
-
-    const result = new AdminUpdateContribution()
-    result.amount = amount
-    result.memo = contributionToUpdate.memo
-    result.date = contributionToUpdate.contributionDate
-
-    result.creation = await getUserCreation(user.id, clientTimezoneOffset)
-
-    const event = new Event()
-    const eventAdminContributionUpdate = new EventAdminContributionUpdate()
-    eventAdminContributionUpdate.userId = user.id
-    eventAdminContributionUpdate.amount = amount
-    eventAdminContributionUpdate.contributionId = contributionToUpdate.id
-    await eventProtocol.writeEvent(
-      event.setEventAdminContributionUpdate(eventAdminContributionUpdate),
-    )
-
-    return result
-  }
-
-  @Authorized([RIGHTS.LIST_UNCONFIRMED_CONTRIBUTIONS])
-  @Query(() => [UnconfirmedContribution])
-  async listUnconfirmedContributions(@Ctx() context: Context): Promise<UnconfirmedContribution[]> {
-    const clientTimezoneOffset = getClientTimezoneOffset(context)
-    const contributions = await getConnection()
-      .createQueryBuilder()
-      .select('c')
-      .from(DbContribution, 'c')
-      .leftJoinAndSelect('c.messages', 'm')
-      .where({ confirmedAt: IsNull() })
-      .getMany()
-
-    if (contributions.length === 0) {
-      return []
-    }
-
-    const userIds = contributions.map((p) => p.userId)
-    const userCreations = await getUserCreations(userIds, clientTimezoneOffset)
-    const users = await dbUser.find({
-      where: { id: In(userIds) },
-      withDeleted: true,
-      relations: ['emailContact'],
-    })
-
-    return contributions.map((contribution) => {
-      const user = users.find((u) => u.id === contribution.userId)
-      const creation = userCreations.find((c) => c.id === contribution.userId)
-
-      return new UnconfirmedContribution(
-        contribution,
-        user,
-        creation ? creation.creations : FULL_CREATION_AVAILABLE,
-      )
-    })
-  }
-
-  @Authorized([RIGHTS.ADMIN_DELETE_CONTRIBUTION])
-  @Mutation(() => Boolean)
-  async adminDeleteContribution(
-    @Arg('id', () => Int) id: number,
-    @Ctx() context: Context,
-  ): Promise<boolean> {
-    const contribution = await DbContribution.findOne(id)
-    if (!contribution) {
-      logger.error(`Contribution not found for given id: ${id}`)
-      throw new Error('Contribution not found for given id.')
-    }
-    const moderator = getUser(context)
-    if (
-      contribution.contributionType === ContributionType.USER &&
-      contribution.userId === moderator.id
-    ) {
-      throw new Error('Own contribution can not be deleted as admin')
-    }
-    const user = await dbUser.findOneOrFail(
-      { id: contribution.userId },
-      { relations: ['emailContact'] },
-    )
-    contribution.contributionStatus = ContributionStatus.DELETED
-    contribution.deletedBy = moderator.id
-    await contribution.save()
-    const res = await contribution.softRemove()
-
-    const event = new Event()
-    const eventAdminContributionDelete = new EventAdminContributionDelete()
-    eventAdminContributionDelete.userId = contribution.userId
-    eventAdminContributionDelete.amount = contribution.amount
-    eventAdminContributionDelete.contributionId = contribution.id
-    await eventProtocol.writeEvent(
-      event.setEventAdminContributionDelete(eventAdminContributionDelete),
-    )
-    sendContributionRejectedEmail({
-      senderFirstName: moderator.firstName,
-      senderLastName: moderator.lastName,
-      recipientEmail: user.emailContact.email,
-      recipientFirstName: user.firstName,
-      recipientLastName: user.lastName,
-      contributionMemo: contribution.memo,
-      contributionAmount: contribution.amount,
-      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
-    })
-
-    return !!res
-  }
-
-  @Authorized([RIGHTS.CONFIRM_CONTRIBUTION])
-  @Mutation(() => Boolean)
-  async confirmContribution(
-    @Arg('id', () => Int) id: number,
-    @Ctx() context: Context,
-  ): Promise<boolean> {
-    const clientTimezoneOffset = getClientTimezoneOffset(context)
-    const contribution = await DbContribution.findOne(id)
-    if (!contribution) {
-      logger.error(`Contribution not found for given id: ${id}`)
-      throw new Error('Contribution not found to given id.')
-    }
-    const moderatorUser = getUser(context)
-    if (moderatorUser.id === contribution.userId) {
-      logger.error('Moderator can not confirm own contribution')
-      throw new Error('Moderator can not confirm own contribution')
-    }
-    const user = await dbUser.findOneOrFail(
-      { id: contribution.userId },
-      { withDeleted: true, relations: ['emailContact'] },
-    )
-    if (user.deletedAt) {
-      logger.error('This user was deleted. Cannot confirm a contribution.')
-      throw new Error('This user was deleted. Cannot confirm a contribution.')
-    }
-    const creations = await getUserCreation(contribution.userId, clientTimezoneOffset, false)
-    validateContribution(
-      creations,
-      contribution.amount,
-      contribution.contributionDate,
-      clientTimezoneOffset,
-    )
-
-    const receivedCallDate = new Date()
-
-    const queryRunner = getConnection().createQueryRunner()
-    await queryRunner.connect()
-    await queryRunner.startTransaction('REPEATABLE READ') // 'READ COMMITTED')
-    try {
-      const lastTransaction = await queryRunner.manager
-        .createQueryBuilder()
-        .select('transaction')
-        .from(DbTransaction, 'transaction')
-        .where('transaction.userId = :id', { id: contribution.userId })
-        .orderBy('transaction.balanceDate', 'DESC')
-        .getOne()
-      logger.info('lastTransaction ID', lastTransaction ? lastTransaction.id : 'undefined')
-
-      let newBalance = new Decimal(0)
-      let decay: Decay | null = null
-      if (lastTransaction) {
-        decay = calculateDecay(
-          lastTransaction.balance,
-          lastTransaction.balanceDate,
-          receivedCallDate,
-        )
-        newBalance = decay.balance
-      }
-      newBalance = newBalance.add(contribution.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 = receivedCallDate
-      transaction.decay = decay ? decay.decay : new Decimal(0)
-      transaction.decayStart = decay ? decay.start : null
-      await queryRunner.manager.insert(DbTransaction, transaction)
-
-      contribution.confirmedAt = receivedCallDate
-      contribution.confirmedBy = moderatorUser.id
-      contribution.transactionId = transaction.id
-      contribution.contributionStatus = ContributionStatus.CONFIRMED
-      await queryRunner.manager.update(DbContribution, { id: contribution.id }, contribution)
-
-      await queryRunner.commitTransaction()
-      logger.info('creation commited successfuly.')
-      sendContributionConfirmedEmail({
-        senderFirstName: moderatorUser.firstName,
-        senderLastName: moderatorUser.lastName,
-        recipientFirstName: user.firstName,
-        recipientLastName: user.lastName,
-        recipientEmail: user.emailContact.email,
-        contributionMemo: contribution.memo,
-        contributionAmount: contribution.amount,
-        overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
-      })
-    } catch (e) {
-      await queryRunner.rollbackTransaction()
-      logger.error(`Creation was not successful: ${e}`)
-      throw new Error(`Creation was not successful.`)
-    } finally {
-      await queryRunner.release()
-    }
-
-    const event = new Event()
-    const eventContributionConfirm = new EventContributionConfirm()
-    eventContributionConfirm.userId = user.id
-    eventContributionConfirm.amount = contribution.amount
-    eventContributionConfirm.contributionId = contribution.id
-    await eventProtocol.writeEvent(event.setEventContributionConfirm(eventContributionConfirm))
-    return true
-  }
-
-  @Authorized([RIGHTS.CREATION_TRANSACTION_LIST])
-  @Query(() => ContributionListResult)
-  async creationTransactionList(
-    @Args()
-    { currentPage = 1, pageSize = 25, order = Order.DESC }: Paginated,
-    @Arg('userId', () => Int) userId: number,
-  ): Promise<ContributionListResult> {
-    const offset = (currentPage - 1) * pageSize
-    const [contributionResult, count] = await getConnection()
-      .createQueryBuilder()
-      .select('c')
-      .from(DbContribution, 'c')
-      .leftJoinAndSelect('c.user', 'u')
-      .where(`user_id = ${userId}`)
-      .limit(pageSize)
-      .offset(offset)
-      .orderBy('c.created_at', order)
-      .getManyAndCount()
-
-    return new ContributionListResult(
-      count,
-      contributionResult.map((contribution) => new Contribution(contribution, contribution.user)),
-    )
-    // return userTransactions.map((t) => new Transaction(t, new User(user), communityUser))
-  }
-
-  @Authorized([RIGHTS.SEND_ACTIVATION_EMAIL])
-  @Mutation(() => Boolean)
-  async sendActivationEmail(@Arg('email') email: string): Promise<boolean> {
-    email = email.trim().toLowerCase()
-    // const user = await dbUser.findOne({ id: emailContact.userId })
-    const user = await findUserByEmail(email)
-    if (!user) {
-      logger.error(`Could not find User to emailContact: ${email}`)
-      throw new Error(`Could not find User to emailContact: ${email}`)
-    }
-    if (user.deletedAt) {
-      logger.error(`User with emailContact: ${email} is deleted.`)
-      throw new Error(`User with emailContact: ${email} is deleted.`)
-    }
-    const emailContact = user.emailContact
-    if (emailContact.deletedAt) {
-      logger.error(`The emailContact: ${email} of htis User is deleted.`)
-      throw new Error(`The emailContact: ${email} of htis User is deleted.`)
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const emailSent = await sendAccountActivationEmail({
-      link: activationLink(emailContact.emailVerificationCode),
-      firstName: user.firstName,
-      lastName: user.lastName,
-      email,
-      duration: printTimeDuration(CONFIG.EMAIL_CODE_VALID_TIME),
-    })
-
-    // In case EMails are disabled log the activation link for the user
-    if (!emailSent) {
-      logger.info(`Account confirmation link: ${activationLink}`)
-    } else {
-      const event = new Event()
-      const eventSendConfirmationEmail = new EventSendConfirmationEmail()
-      eventSendConfirmationEmail.userId = user.id
-      await eventProtocol.writeEvent(
-        event.setEventSendConfirmationEmail(eventSendConfirmationEmail),
-      )
-    }
-
-    return true
-  }
-
-  @Authorized([RIGHTS.LIST_TRANSACTION_LINKS_ADMIN])
-  @Query(() => TransactionLinkResult)
-  async listTransactionLinksAdmin(
-    @Args()
-    { currentPage = 1, pageSize = 5, order = Order.DESC }: Paginated,
-    @Arg('filters', () => TransactionLinkFilters, { nullable: true })
-    filters: TransactionLinkFilters,
-    @Arg('userId', () => Int)
-    userId: number,
-  ): Promise<TransactionLinkResult> {
-    const user = await dbUser.findOneOrFail({ id: userId })
-    const where: {
-      userId: number
-      redeemedBy?: number | null
-      validUntil?: FindOperator<Date> | null
-    } = {
-      userId,
-      redeemedBy: null,
-      validUntil: MoreThan(new Date()),
-    }
-    if (filters) {
-      if (filters.withRedeemed) delete where.redeemedBy
-      if (filters.withExpired) delete where.validUntil
-    }
-    const [transactionLinks, count] = await dbTransactionLink.findAndCount({
-      where,
-      withDeleted: filters ? filters.withDeleted : false,
-      order: {
-        createdAt: order,
-      },
-      skip: (currentPage - 1) * pageSize,
-      take: pageSize,
-    })
-
-    return {
-      linkCount: count,
-      linkList: transactionLinks.map((tl) => new TransactionLink(tl, new User(user))),
-    }
-  }
-
-  @Authorized([RIGHTS.CREATE_CONTRIBUTION_LINK])
-  @Mutation(() => ContributionLink)
-  async createContributionLink(
-    @Args()
-    {
-      amount,
-      name,
-      memo,
-      cycle,
-      validFrom,
-      validTo,
-      maxAmountPerMonth,
-      maxPerCycle,
-    }: ContributionLinkArgs,
-  ): Promise<ContributionLink> {
-    isStartEndDateValid(validFrom, validTo)
-    if (!name) {
-      logger.error(`The name must be initialized!`)
-      throw new Error(`The name must be initialized!`)
-    }
-    if (
-      name.length < CONTRIBUTIONLINK_NAME_MIN_CHARS ||
-      name.length > CONTRIBUTIONLINK_NAME_MAX_CHARS
-    ) {
-      const msg = `The value of 'name' with a length of ${name.length} did not fulfill the requested bounderies min=${CONTRIBUTIONLINK_NAME_MIN_CHARS} and max=${CONTRIBUTIONLINK_NAME_MAX_CHARS}`
-      logger.error(`${msg}`)
-      throw new Error(`${msg}`)
-    }
-    if (!memo) {
-      logger.error(`The memo must be initialized!`)
-      throw new Error(`The memo must be initialized!`)
-    }
-    if (memo.length < MEMO_MIN_CHARS || memo.length > MEMO_MAX_CHARS) {
-      const msg = `The value of 'memo' with a length of ${memo.length} did not fulfill the requested bounderies min=${MEMO_MIN_CHARS} and max=${MEMO_MAX_CHARS}`
-      logger.error(`${msg}`)
-      throw new Error(`${msg}`)
-    }
-    if (!amount) {
-      logger.error(`The amount must be initialized!`)
-      throw new Error('The amount must be initialized!')
-    }
-    if (!new Decimal(amount).isPositive()) {
-      logger.error(`The amount=${amount} must be initialized with a positiv value!`)
-      throw new Error(`The amount=${amount} must be initialized with a positiv value!`)
-    }
-    const dbContributionLink = new DbContributionLink()
-    dbContributionLink.amount = amount
-    dbContributionLink.name = name
-    dbContributionLink.memo = memo
-    dbContributionLink.createdAt = new Date()
-    dbContributionLink.code = contributionLinkCode(dbContributionLink.createdAt)
-    dbContributionLink.cycle = cycle
-    if (validFrom) dbContributionLink.validFrom = new Date(validFrom)
-    if (validTo) dbContributionLink.validTo = new Date(validTo)
-    dbContributionLink.maxAmountPerMonth = maxAmountPerMonth
-    dbContributionLink.maxPerCycle = maxPerCycle
-    await dbContributionLink.save()
-    logger.debug(`createContributionLink successful!`)
-    return new ContributionLink(dbContributionLink)
-  }
-
-  @Authorized([RIGHTS.LIST_CONTRIBUTION_LINKS])
-  @Query(() => ContributionLinkList)
-  async listContributionLinks(
-    @Args()
-    { currentPage = 1, pageSize = 5, order = Order.DESC }: Paginated,
-  ): Promise<ContributionLinkList> {
-    const [links, count] = await DbContributionLink.findAndCount({
-      where: [{ validTo: MoreThan(new Date()) }, { validTo: IsNull() }],
-      order: { createdAt: order },
-      skip: (currentPage - 1) * pageSize,
-      take: pageSize,
-    })
-    return {
-      links: links.map((link: DbContributionLink) => new ContributionLink(link)),
-      count,
-    }
-  }
-
-  @Authorized([RIGHTS.DELETE_CONTRIBUTION_LINK])
-  @Mutation(() => Date, { nullable: true })
-  async deleteContributionLink(@Arg('id', () => Int) id: number): Promise<Date | null> {
-    const contributionLink = await DbContributionLink.findOne(id)
-    if (!contributionLink) {
-      logger.error(`Contribution Link not found to given id: ${id}`)
-      throw new Error('Contribution Link not found to given id.')
-    }
-    await contributionLink.softRemove()
-    logger.debug(`deleteContributionLink successful!`)
-    const newContributionLink = await DbContributionLink.findOne({ id }, { withDeleted: true })
-    return newContributionLink ? newContributionLink.deletedAt : null
-  }
-
-  @Authorized([RIGHTS.UPDATE_CONTRIBUTION_LINK])
-  @Mutation(() => ContributionLink)
-  async updateContributionLink(
-    @Args()
-    {
-      amount,
-      name,
-      memo,
-      cycle,
-      validFrom,
-      validTo,
-      maxAmountPerMonth,
-      maxPerCycle,
-    }: ContributionLinkArgs,
-    @Arg('id', () => Int) id: number,
-  ): Promise<ContributionLink> {
-    const dbContributionLink = await DbContributionLink.findOne(id)
-    if (!dbContributionLink) {
-      logger.error(`Contribution Link not found to given id: ${id}`)
-      throw new Error('Contribution Link not found to given id.')
-    }
-    dbContributionLink.amount = amount
-    dbContributionLink.name = name
-    dbContributionLink.memo = memo
-    dbContributionLink.cycle = cycle
-    if (validFrom) dbContributionLink.validFrom = new Date(validFrom)
-    if (validTo) dbContributionLink.validTo = new Date(validTo)
-    dbContributionLink.maxAmountPerMonth = maxAmountPerMonth
-    dbContributionLink.maxPerCycle = maxPerCycle
-    await dbContributionLink.save()
-    logger.debug(`updateContributionLink successful!`)
-    return new ContributionLink(dbContributionLink)
-  }
-
-  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTION_MESSAGE])
-  @Mutation(() => ContributionMessage)
-  async adminCreateContributionMessage(
-    @Args() { contributionId, message }: ContributionMessageArgs,
-    @Ctx() context: Context,
-  ): Promise<ContributionMessage> {
-    const user = getUser(context)
-    if (!user.emailContact) {
-      user.emailContact = await UserContact.findOneOrFail({ where: { id: user.emailId } })
-    }
-    const queryRunner = getConnection().createQueryRunner()
-    await queryRunner.connect()
-    await queryRunner.startTransaction('REPEATABLE READ')
-    const contributionMessage = DbContributionMessage.create()
-    try {
-      const contribution = await DbContribution.findOne({
-        where: { id: contributionId },
-        relations: ['user'],
-      })
-      if (!contribution) {
-        logger.error('Contribution not found')
-        throw new Error('Contribution not found')
-      }
-      if (contribution.userId === user.id) {
-        logger.error('Admin can not answer on own contribution')
-        throw new Error('Admin can not answer on own contribution')
-      }
-      if (!contribution.user.emailContact) {
-        contribution.user.emailContact = await UserContact.findOneOrFail({
-          where: { id: contribution.user.emailId },
-        })
-      }
-      contributionMessage.contributionId = contributionId
-      contributionMessage.createdAt = new Date()
-      contributionMessage.message = message
-      contributionMessage.userId = user.id
-      contributionMessage.type = ContributionMessageType.DIALOG
-      contributionMessage.isModerator = true
-      await queryRunner.manager.insert(DbContributionMessage, contributionMessage)
-
-      if (
-        contribution.contributionStatus === ContributionStatus.DELETED ||
-        contribution.contributionStatus === ContributionStatus.DENIED ||
-        contribution.contributionStatus === ContributionStatus.PENDING
-      ) {
-        contribution.contributionStatus = ContributionStatus.IN_PROGRESS
-        await queryRunner.manager.update(DbContribution, { id: contributionId }, contribution)
-      }
-
-      await sendAddedContributionMessageEmail({
-        senderFirstName: user.firstName,
-        senderLastName: user.lastName,
-        recipientFirstName: contribution.user.firstName,
-        recipientLastName: contribution.user.lastName,
-        recipientEmail: contribution.user.emailContact.email,
-        senderEmail: user.emailContact.email,
-        contributionMemo: contribution.memo,
-        message,
-        overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
-      })
-      await queryRunner.commitTransaction()
-    } catch (e) {
-      await queryRunner.rollbackTransaction()
-      logger.error(`ContributionMessage was not successful: ${e}`)
-      throw new Error(`ContributionMessage was not successful: ${e}`)
-    } finally {
-      await queryRunner.release()
-    }
-    return new ContributionMessage(contributionMessage, user)
-  }
-}

backend/src/graphql/resolver/BalanceResolver.ts

@@ -1,16 +1,19 @@
-import { backendLogger as logger } from '@/server/logger'
-
-import { Context, getUser } from '@/server/context'
+import Decimal from 'decimal.js-light'
 import { Resolver, Query, Ctx, Authorized } from 'type-graphql'
+import { getCustomRepository } from '@dbTools/typeorm'
+
+import { Transaction as dbTransaction } from '@entity/Transaction'
+import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
+
+import { TransactionLinkRepository } from '@repository/TransactionLink'
+
 import { Balance } from '@model/Balance'
+
+import { backendLogger as logger } from '@/server/logger'
+import { Context, getUser } from '@/server/context'
 import { calculateDecay } from '@/util/decay'
 import { RIGHTS } from '@/auth/RIGHTS'
-import { Transaction as dbTransaction } from '@entity/Transaction'
-import Decimal from 'decimal.js-light'
 import { GdtResolver } from './GdtResolver'
-import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
-import { getCustomRepository } from '@dbTools/typeorm'
-import { TransactionLinkRepository } from '@repository/TransactionLink'
 
 @Resolver()
 export class BalanceResolver {

backend/src/graphql/resolver/CommunityResolver.ts

@@ -1,7 +1,9 @@
 import { Resolver, Query, Authorized } from 'type-graphql'
+
+import { Community } from '@model/Community'
+
 import { RIGHTS } from '@/auth/RIGHTS'
 import CONFIG from '@/config'
-import { Community } from '@model/Community'
 
 @Resolver()
 export class CommunityResolver {

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

@@ -0,0 +1,649 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import Decimal from 'decimal.js-light'
+import { logger } from '@test/testSetup'
+import { GraphQLError } from 'graphql'
+import {
+  login,
+  createContributionLink,
+  deleteContributionLink,
+  updateContributionLink,
+} from '@/seeds/graphql/mutations'
+import { listContributionLinks } from '@/seeds/graphql/queries'
+import { cleanDB, testEnvironment, resetToken } from '@test/helpers'
+import { bibiBloxberg } from '@/seeds/users/bibi-bloxberg'
+import { peterLustig } from '@/seeds/users/peter-lustig'
+import { userFactory } from '@/seeds/factory/user'
+import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+
+let mutate: any, query: any, con: any
+let testEnv: any
+
+beforeAll(async () => {
+  testEnv = await testEnvironment()
+  mutate = testEnv.mutate
+  query = testEnv.query
+  con = testEnv.con
+  await cleanDB()
+  await userFactory(testEnv, bibiBloxberg)
+  await userFactory(testEnv, peterLustig)
+})
+
+afterAll(async () => {
+  await cleanDB()
+  await con.close()
+})
+
+describe('Contribution Links', () => {
+  const now = new Date()
+  const variables = {
+    amount: new Decimal(200),
+    name: 'Dokumenta 2022',
+    memo: 'Danke für deine Teilnahme an der Dokumenta 2022',
+    cycle: 'once',
+    validFrom: new Date(2022, 5, 18).toISOString(),
+    validTo: new Date(now.getFullYear() + 1, 7, 14).toISOString(),
+    maxAmountPerMonth: new Decimal(200),
+    maxPerCycle: 1,
+  }
+
+  describe('unauthenticated', () => {
+    afterAll(async () => {
+      await cleanDB()
+      resetToken()
+    })
+
+    describe('createContributionLink', () => {
+      it('returns an error', async () => {
+        await expect(mutate({ mutation: createContributionLink, variables })).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('listContributionLinks', () => {
+      it('returns an error', async () => {
+        await expect(query({ query: listContributionLinks })).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('updateContributionLink', () => {
+      it('returns an error', async () => {
+        await expect(
+          mutate({
+            mutation: updateContributionLink,
+            variables: {
+              ...variables,
+              id: -1,
+              amount: new Decimal(400),
+              name: 'Dokumenta 2023',
+              memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+            },
+          }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('deleteContributionLink', () => {
+      it('returns an error', async () => {
+        await expect(
+          mutate({ mutation: deleteContributionLink, variables: { id: -1 } }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+  })
+
+  describe('authenticated', () => {
+    describe('without admin rights', () => {
+      beforeAll(async () => {
+        await userFactory(testEnv, bibiBloxberg)
+        await mutate({
+          mutation: login,
+          variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+        })
+      })
+
+      afterAll(async () => {
+        await cleanDB()
+        resetToken()
+      })
+
+      describe('createContributionLink', () => {
+        it('returns an error', async () => {
+          await expect(mutate({ mutation: createContributionLink, variables })).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      // TODO: Set this test in new location to have datas
+      describe('listContributionLinks', () => {
+        it('returns an empty object', async () => {
+          await expect(query({ query: listContributionLinks })).resolves.toEqual(
+            expect.objectContaining({
+              data: {
+                listContributionLinks: {
+                  count: 0,
+                  links: [],
+                },
+              },
+            }),
+          )
+        })
+      })
+
+      describe('updateContributionLink', () => {
+        it('returns an error', async () => {
+          await expect(
+            mutate({
+              mutation: updateContributionLink,
+              variables: {
+                ...variables,
+                id: -1,
+                amount: new Decimal(400),
+                name: 'Dokumenta 2023',
+                memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('deleteContributionLink', () => {
+        it('returns an error', async () => {
+          await expect(
+            mutate({ mutation: deleteContributionLink, variables: { id: -1 } }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+    })
+
+    describe('with admin rights', () => {
+      beforeAll(async () => {
+        await userFactory(testEnv, peterLustig)
+        await mutate({
+          mutation: login,
+          variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+        })
+      })
+
+      afterAll(async () => {
+        await cleanDB()
+        resetToken()
+      })
+
+      describe('createContributionLink', () => {
+        it('returns a contribution link object', async () => {
+          await expect(mutate({ mutation: createContributionLink, variables })).resolves.toEqual(
+            expect.objectContaining({
+              data: {
+                createContributionLink: expect.objectContaining({
+                  id: expect.any(Number),
+                  amount: '200',
+                  code: expect.stringMatching(/^[0-9a-f]{24,24}$/),
+                  link: expect.stringMatching(/^.*?\/CL-[0-9a-f]{24,24}$/),
+                  createdAt: expect.any(String),
+                  name: 'Dokumenta 2022',
+                  memo: 'Danke für deine Teilnahme an der Dokumenta 2022',
+                  validFrom: expect.any(String),
+                  validTo: expect.any(String),
+                  maxAmountPerMonth: '200',
+                  cycle: 'once',
+                  maxPerCycle: 1,
+                }),
+              },
+            }),
+          )
+        })
+
+        it('has a contribution link stored in db', async () => {
+          const cls = await DbContributionLink.find()
+          expect(cls).toHaveLength(1)
+          expect(cls[0]).toEqual(
+            expect.objectContaining({
+              id: expect.any(Number),
+              name: 'Dokumenta 2022',
+              memo: 'Danke für deine Teilnahme an der Dokumenta 2022',
+              validFrom: new Date('2022-06-18T00:00:00.000Z'),
+              validTo: expect.any(Date),
+              cycle: 'once',
+              maxPerCycle: 1,
+              totalMaxCountOfContribution: null,
+              maxAccountBalance: null,
+              minGapHours: null,
+              createdAt: expect.any(Date),
+              deletedAt: null,
+              code: expect.stringMatching(/^[0-9a-f]{24,24}$/),
+              linkEnabled: true,
+              amount: expect.decimalEqual(200),
+              maxAmountPerMonth: expect.decimalEqual(200),
+            }),
+          )
+        })
+
+        it('returns an error if missing startDate', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                validFrom: null,
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError('Start-Date is not initialized. A Start-Date must be set!'),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            'Start-Date is not initialized. A Start-Date must be set!',
+          )
+        })
+
+        it('returns an error if missing endDate', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                validTo: null,
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('End-Date is not initialized. An End-Date must be set!')],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            'End-Date is not initialized. An End-Date must be set!',
+          )
+        })
+
+        it('returns an error if endDate is before startDate', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                validFrom: new Date('2022-06-18T00:00:00.001Z').toISOString(),
+                validTo: new Date('2022-06-18T00:00:00.000Z').toISOString(),
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError(`The value of validFrom must before or equals the validTo!`),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            `The value of validFrom must before or equals the validTo!`,
+          )
+        })
+
+        it('returns an error if name is an empty string', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                name: '',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('The name must be initialized!')],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith('The name must be initialized!')
+        })
+
+        it('returns an error if name is shorter than 5 characters', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                name: '123',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError(
+                  `The value of 'name' with a length of 3 did not fulfill the requested bounderies min=5 and max=100`,
+                ),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            `The value of 'name' with a length of 3 did not fulfill the requested bounderies min=5 and max=100`,
+          )
+        })
+
+        it('returns an error if name is longer than 100 characters', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                name: '12345678901234567892123456789312345678941234567895123456789612345678971234567898123456789912345678901',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError(
+                  `The value of 'name' with a length of 101 did not fulfill the requested bounderies min=5 and max=100`,
+                ),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            `The value of 'name' with a length of 101 did not fulfill the requested bounderies min=5 and max=100`,
+          )
+        })
+
+        it('returns an error if memo is an empty string', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                memo: '',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('The memo must be initialized!')],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith('The memo must be initialized!')
+        })
+
+        it('returns an error if memo is shorter than 5 characters', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                memo: '123',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError(
+                  `The value of 'memo' with a length of 3 did not fulfill the requested bounderies min=5 and max=255`,
+                ),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            `The value of 'memo' with a length of 3 did not fulfill the requested bounderies min=5 and max=255`,
+          )
+        })
+
+        it('returns an error if memo is longer than 255 characters', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                memo: '1234567890123456789212345678931234567894123456789512345678961234567897123456789812345678991234567890123456789012345678921234567893123456789412345678951234567896123456789712345678981234567899123456789012345678901234567892123456789312345678941234567895123456',
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [
+                new GraphQLError(
+                  `The value of 'memo' with a length of 256 did not fulfill the requested bounderies min=5 and max=255`,
+                ),
+              ],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            `The value of 'memo' with a length of 256 did not fulfill the requested bounderies min=5 and max=255`,
+          )
+        })
+
+        it('returns an error if amount is not positive', async () => {
+          await expect(
+            mutate({
+              mutation: createContributionLink,
+              variables: {
+                ...variables,
+                amount: new Decimal(0),
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('The amount=0 must be initialized with a positiv value!')],
+            }),
+          )
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith(
+            'The amount=0 must be initialized with a positiv value!',
+          )
+        })
+      })
+
+      describe('listContributionLinks', () => {
+        describe('one link in DB', () => {
+          it('returns the link and count 1', async () => {
+            await expect(query({ query: listContributionLinks })).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listContributionLinks: {
+                    links: expect.arrayContaining([
+                      expect.objectContaining({
+                        amount: '200',
+                        code: expect.stringMatching(/^[0-9a-f]{24,24}$/),
+                        link: expect.stringMatching(/^.*?\/CL-[0-9a-f]{24,24}$/),
+                        createdAt: expect.any(String),
+                        name: 'Dokumenta 2022',
+                        memo: 'Danke für deine Teilnahme an der Dokumenta 2022',
+                        validFrom: expect.any(String),
+                        validTo: expect.any(String),
+                        maxAmountPerMonth: '200',
+                        cycle: 'once',
+                        maxPerCycle: 1,
+                      }),
+                    ]),
+                    count: 1,
+                  },
+                },
+              }),
+            )
+          })
+        })
+      })
+
+      describe('updateContributionLink', () => {
+        describe('no valid id', () => {
+          it('returns an error', async () => {
+            await expect(
+              mutate({
+                mutation: updateContributionLink,
+                variables: {
+                  ...variables,
+                  id: -1,
+                  amount: new Decimal(400),
+                  name: 'Dokumenta 2023',
+                  memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError('Contribution Link not found to given id.')],
+              }),
+            )
+          })
+        })
+
+        it('logs the error thrown', () => {
+          expect(logger.error).toBeCalledWith('Contribution Link not found to given id: -1')
+        })
+
+        describe('valid id', () => {
+          let linkId: number
+          beforeAll(async () => {
+            const links = await query({ query: listContributionLinks })
+            linkId = links.data.listContributionLinks.links[0].id
+          })
+
+          it('returns updated contribution link object', async () => {
+            await expect(
+              mutate({
+                mutation: updateContributionLink,
+                variables: {
+                  ...variables,
+                  id: linkId,
+                  amount: new Decimal(400),
+                  name: 'Dokumenta 2023',
+                  memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  updateContributionLink: {
+                    id: linkId,
+                    amount: '400',
+                    code: expect.stringMatching(/^[0-9a-f]{24,24}$/),
+                    link: expect.stringMatching(/^.*?\/CL-[0-9a-f]{24,24}$/),
+                    createdAt: expect.any(String),
+                    name: 'Dokumenta 2023',
+                    memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+                    validFrom: expect.any(String),
+                    validTo: expect.any(String),
+                    maxAmountPerMonth: '200',
+                    cycle: 'once',
+                    maxPerCycle: 1,
+                  },
+                },
+              }),
+            )
+          })
+
+          it('updated the DB record', async () => {
+            await expect(DbContributionLink.findOne(linkId)).resolves.toEqual(
+              expect.objectContaining({
+                id: linkId,
+                name: 'Dokumenta 2023',
+                memo: 'Danke für deine Teilnahme an der Dokumenta 2023',
+                amount: expect.decimalEqual(400),
+              }),
+            )
+          })
+        })
+      })
+
+      describe('deleteContributionLink', () => {
+        describe('no valid id', () => {
+          it('returns an error', async () => {
+            await expect(
+              mutate({ mutation: deleteContributionLink, variables: { id: -1 } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError('Contribution Link not found to given id.')],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith('Contribution Link not found to given id: -1')
+          })
+        })
+
+        describe('valid id', () => {
+          let linkId: number
+          beforeAll(async () => {
+            const links = await query({ query: listContributionLinks })
+            linkId = links.data.listContributionLinks.links[0].id
+          })
+
+          it('returns a date string', async () => {
+            await expect(
+              mutate({ mutation: deleteContributionLink, variables: { id: linkId } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  deleteContributionLink: expect.any(String),
+                },
+              }),
+            )
+          })
+
+          it('does not list this contribution link anymore', async () => {
+            await expect(query({ query: listContributionLinks })).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listContributionLinks: {
+                    links: [],
+                    count: 0,
+                  },
+                },
+              }),
+            )
+          })
+        })
+      })
+    })
+  })
+})

backend/src/graphql/resolver/ContributionLinkResolver.ts

@@ -0,0 +1,152 @@
+import Decimal from 'decimal.js-light'
+import { Resolver, Args, Arg, Authorized, Mutation, Query, Int } from 'type-graphql'
+import { MoreThan, IsNull } from '@dbTools/typeorm'
+
+import {
+  CONTRIBUTIONLINK_NAME_MAX_CHARS,
+  CONTRIBUTIONLINK_NAME_MIN_CHARS,
+  MEMO_MAX_CHARS,
+  MEMO_MIN_CHARS,
+} from './const/const'
+import { isStartEndDateValid } from './util/creations'
+import { ContributionLinkList } from '@model/ContributionLinkList'
+import { ContributionLink } from '@model/ContributionLink'
+import ContributionLinkArgs from '@arg/ContributionLinkArgs'
+import { backendLogger as logger } from '@/server/logger'
+import { RIGHTS } from '@/auth/RIGHTS'
+import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+import { Order } from '@enum/Order'
+import Paginated from '@arg/Paginated'
+
+// TODO: this is a strange construct
+import { transactionLinkCode as contributionLinkCode } from './TransactionLinkResolver'
+
+@Resolver()
+export class ContributionLinkResolver {
+  @Authorized([RIGHTS.CREATE_CONTRIBUTION_LINK])
+  @Mutation(() => ContributionLink)
+  async createContributionLink(
+    @Args()
+    {
+      amount,
+      name,
+      memo,
+      cycle,
+      validFrom,
+      validTo,
+      maxAmountPerMonth,
+      maxPerCycle,
+    }: ContributionLinkArgs,
+  ): Promise<ContributionLink> {
+    isStartEndDateValid(validFrom, validTo)
+    if (!name) {
+      logger.error(`The name must be initialized!`)
+      throw new Error(`The name must be initialized!`)
+    }
+    if (
+      name.length < CONTRIBUTIONLINK_NAME_MIN_CHARS ||
+      name.length > CONTRIBUTIONLINK_NAME_MAX_CHARS
+    ) {
+      const msg = `The value of 'name' with a length of ${name.length} did not fulfill the requested bounderies min=${CONTRIBUTIONLINK_NAME_MIN_CHARS} and max=${CONTRIBUTIONLINK_NAME_MAX_CHARS}`
+      logger.error(`${msg}`)
+      throw new Error(`${msg}`)
+    }
+    if (!memo) {
+      logger.error(`The memo must be initialized!`)
+      throw new Error(`The memo must be initialized!`)
+    }
+    if (memo.length < MEMO_MIN_CHARS || memo.length > MEMO_MAX_CHARS) {
+      const msg = `The value of 'memo' with a length of ${memo.length} did not fulfill the requested bounderies min=${MEMO_MIN_CHARS} and max=${MEMO_MAX_CHARS}`
+      logger.error(`${msg}`)
+      throw new Error(`${msg}`)
+    }
+    if (!amount) {
+      logger.error(`The amount must be initialized!`)
+      throw new Error('The amount must be initialized!')
+    }
+    if (!new Decimal(amount).isPositive()) {
+      logger.error(`The amount=${amount} must be initialized with a positiv value!`)
+      throw new Error(`The amount=${amount} must be initialized with a positiv value!`)
+    }
+    const dbContributionLink = new DbContributionLink()
+    dbContributionLink.amount = amount
+    dbContributionLink.name = name
+    dbContributionLink.memo = memo
+    dbContributionLink.createdAt = new Date()
+    dbContributionLink.code = contributionLinkCode(dbContributionLink.createdAt)
+    dbContributionLink.cycle = cycle
+    if (validFrom) dbContributionLink.validFrom = new Date(validFrom)
+    if (validTo) dbContributionLink.validTo = new Date(validTo)
+    dbContributionLink.maxAmountPerMonth = maxAmountPerMonth
+    dbContributionLink.maxPerCycle = maxPerCycle
+    await dbContributionLink.save()
+    logger.debug(`createContributionLink successful!`)
+    return new ContributionLink(dbContributionLink)
+  }
+
+  @Authorized([RIGHTS.LIST_CONTRIBUTION_LINKS])
+  @Query(() => ContributionLinkList)
+  async listContributionLinks(
+    @Args()
+    { currentPage = 1, pageSize = 5, order = Order.DESC }: Paginated,
+  ): Promise<ContributionLinkList> {
+    const [links, count] = await DbContributionLink.findAndCount({
+      where: [{ validTo: MoreThan(new Date()) }, { validTo: IsNull() }],
+      order: { createdAt: order },
+      skip: (currentPage - 1) * pageSize,
+      take: pageSize,
+    })
+    return {
+      links: links.map((link: DbContributionLink) => new ContributionLink(link)),
+      count,
+    }
+  }
+
+  @Authorized([RIGHTS.DELETE_CONTRIBUTION_LINK])
+  @Mutation(() => Date, { nullable: true })
+  async deleteContributionLink(@Arg('id', () => Int) id: number): Promise<Date | null> {
+    const contributionLink = await DbContributionLink.findOne(id)
+    if (!contributionLink) {
+      logger.error(`Contribution Link not found to given id: ${id}`)
+      throw new Error('Contribution Link not found to given id.')
+    }
+    await contributionLink.softRemove()
+    logger.debug(`deleteContributionLink successful!`)
+    const newContributionLink = await DbContributionLink.findOne({ id }, { withDeleted: true })
+    return newContributionLink ? newContributionLink.deletedAt : null
+  }
+
+  @Authorized([RIGHTS.UPDATE_CONTRIBUTION_LINK])
+  @Mutation(() => ContributionLink)
+  async updateContributionLink(
+    @Args()
+    {
+      amount,
+      name,
+      memo,
+      cycle,
+      validFrom,
+      validTo,
+      maxAmountPerMonth,
+      maxPerCycle,
+    }: ContributionLinkArgs,
+    @Arg('id', () => Int) id: number,
+  ): Promise<ContributionLink> {
+    const dbContributionLink = await DbContributionLink.findOne(id)
+    if (!dbContributionLink) {
+      logger.error(`Contribution Link not found to given id: ${id}`)
+      throw new Error('Contribution Link not found to given id.')
+    }
+    dbContributionLink.amount = amount
+    dbContributionLink.name = name
+    dbContributionLink.memo = memo
+    dbContributionLink.cycle = cycle
+    if (validFrom) dbContributionLink.validFrom = new Date(validFrom)
+    if (validTo) dbContributionLink.validTo = new Date(validTo)
+    dbContributionLink.maxAmountPerMonth = maxAmountPerMonth
+    dbContributionLink.maxPerCycle = maxPerCycle
+    await dbContributionLink.save()
+    logger.debug(`updateContributionLink successful!`)
+    return new ContributionLink(dbContributionLink)
+  }
+}

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

@@ -2,6 +2,7 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 
 import { cleanDB, resetToken, testEnvironment } from '@test/helpers'
+import { logger, i18n as localization } from '@test/testSetup'
 import { GraphQLError } from 'graphql'
 import {
   adminCreateContributionMessage,
@@ -13,12 +14,16 @@ import { listContributionMessages } from '@/seeds/graphql/queries'
 import { userFactory } from '@/seeds/factory/user'
 import { bibiBloxberg } from '@/seeds/users/bibi-bloxberg'
 import { peterLustig } from '@/seeds/users/peter-lustig'
-import { sendAddedContributionMessageEmail } from '@/mailer/sendAddedContributionMessageEmail'
+import { sendAddedContributionMessageEmail } from '@/emails/sendEmailVariants'
 
-jest.mock('@/mailer/sendAddedContributionMessageEmail', () => {
+jest.mock('@/emails/sendEmailVariants', () => {
+  const originalModule = jest.requireActual('@/emails/sendEmailVariants')
   return {
     __esModule: true,
-    sendAddedContributionMessageEmail: jest.fn(),
+    ...originalModule,
+    sendAddedContributionMessageEmail: jest.fn((a) =>
+      originalModule.sendAddedContributionMessageEmail(a),
+    ),
   }
 })
 
@@ -27,7 +32,7 @@ let testEnv: any
 let result: any
 
 beforeAll(async () => {
-  testEnv = await testEnvironment()
+  testEnv = await testEnvironment(logger, localization)
   mutate = testEnv.mutate
   con = testEnv.con
   await cleanDB()
@@ -162,15 +167,13 @@ describe('ContributionMessageResolver', () => {
 
         it('calls sendAddedContributionMessageEmail', async () => {
           expect(sendAddedContributionMessageEmail).toBeCalledWith({
+            firstName: 'Bibi',
+            lastName: 'Bloxberg',
+            email: 'bibi@bloxberg.de',
+            language: 'de',
             senderFirstName: 'Peter',
             senderLastName: 'Lustig',
-            recipientFirstName: 'Bibi',
-            recipientLastName: 'Bloxberg',
-            recipientEmail: 'bibi@bloxberg.de',
-            senderEmail: 'peter@lustig.de',
             contributionMemo: 'Test env contribution',
-            message: 'Admin Test',
-            overviewURL: 'http://localhost/overview',
           })
         })
       })

backend/src/graphql/resolver/ContributionMessageResolver.ts

@@ -1,16 +1,21 @@
+import { Arg, Args, Authorized, Ctx, Mutation, Query, Resolver } from 'type-graphql'
+import { getConnection } from '@dbTools/typeorm'
+
+import { ContributionMessage as DbContributionMessage } from '@entity/ContributionMessage'
+import { Contribution as DbContribution } from '@entity/Contribution'
+import { UserContact } from '@entity/UserContact'
+
+import { ContributionMessage, ContributionMessageListResult } from '@model/ContributionMessage'
+import ContributionMessageArgs from '@arg/ContributionMessageArgs'
+import { ContributionMessageType } from '@enum/MessageType'
+import { ContributionStatus } from '@enum/ContributionStatus'
+import { Order } from '@enum/Order'
+import Paginated from '@arg/Paginated'
+
 import { backendLogger as logger } from '@/server/logger'
 import { RIGHTS } from '@/auth/RIGHTS'
 import { Context, getUser } from '@/server/context'
-import { ContributionMessage as DbContributionMessage } from '@entity/ContributionMessage'
-import { Arg, Args, Authorized, Ctx, Mutation, Query, Resolver } from 'type-graphql'
-import ContributionMessageArgs from '@arg/ContributionMessageArgs'
-import { Contribution } from '@entity/Contribution'
-import { ContributionMessageType } from '@enum/MessageType'
-import { ContributionStatus } from '@enum/ContributionStatus'
-import { getConnection } from '@dbTools/typeorm'
-import { ContributionMessage, ContributionMessageListResult } from '@model/ContributionMessage'
-import Paginated from '@arg/Paginated'
-import { Order } from '@enum/Order'
+import { sendAddedContributionMessageEmail } from '@/emails/sendEmailVariants'
 
 @Resolver()
 export class ContributionMessageResolver {
@@ -26,7 +31,7 @@ export class ContributionMessageResolver {
     await queryRunner.startTransaction('REPEATABLE READ')
     const contributionMessage = DbContributionMessage.create()
     try {
-      const contribution = await Contribution.findOne({ id: contributionId })
+      const contribution = await DbContribution.findOne({ id: contributionId })
       if (!contribution) {
         throw new Error('Contribution not found')
       }
@@ -44,7 +49,7 @@ export class ContributionMessageResolver {
 
       if (contribution.contributionStatus === ContributionStatus.IN_PROGRESS) {
         contribution.contributionStatus = ContributionStatus.PENDING
-        await queryRunner.manager.update(Contribution, { id: contributionId }, contribution)
+        await queryRunner.manager.update(DbContribution, { id: contributionId }, contribution)
       }
       await queryRunner.commitTransaction()
     } catch (e) {
@@ -82,4 +87,73 @@ export class ContributionMessageResolver {
       ),
     }
   }
+
+  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTION_MESSAGE])
+  @Mutation(() => ContributionMessage)
+  async adminCreateContributionMessage(
+    @Args() { contributionId, message }: ContributionMessageArgs,
+    @Ctx() context: Context,
+  ): Promise<ContributionMessage> {
+    const user = getUser(context)
+    if (!user.emailContact) {
+      user.emailContact = await UserContact.findOneOrFail({ where: { id: user.emailId } })
+    }
+    const queryRunner = getConnection().createQueryRunner()
+    await queryRunner.connect()
+    await queryRunner.startTransaction('REPEATABLE READ')
+    const contributionMessage = DbContributionMessage.create()
+    try {
+      const contribution = await DbContribution.findOne({
+        where: { id: contributionId },
+        relations: ['user'],
+      })
+      if (!contribution) {
+        logger.error('Contribution not found')
+        throw new Error('Contribution not found')
+      }
+      if (contribution.userId === user.id) {
+        logger.error('Admin can not answer on own contribution')
+        throw new Error('Admin can not answer on own contribution')
+      }
+      if (!contribution.user.emailContact) {
+        contribution.user.emailContact = await UserContact.findOneOrFail({
+          where: { id: contribution.user.emailId },
+        })
+      }
+      contributionMessage.contributionId = contributionId
+      contributionMessage.createdAt = new Date()
+      contributionMessage.message = message
+      contributionMessage.userId = user.id
+      contributionMessage.type = ContributionMessageType.DIALOG
+      contributionMessage.isModerator = true
+      await queryRunner.manager.insert(DbContributionMessage, contributionMessage)
+
+      if (
+        contribution.contributionStatus === ContributionStatus.DELETED ||
+        contribution.contributionStatus === ContributionStatus.DENIED ||
+        contribution.contributionStatus === ContributionStatus.PENDING
+      ) {
+        contribution.contributionStatus = ContributionStatus.IN_PROGRESS
+        await queryRunner.manager.update(DbContribution, { id: contributionId }, contribution)
+      }
+
+      await sendAddedContributionMessageEmail({
+        firstName: contribution.user.firstName,
+        lastName: contribution.user.lastName,
+        email: contribution.user.emailContact.email,
+        language: contribution.user.language,
+        senderFirstName: user.firstName,
+        senderLastName: user.lastName,
+        contributionMemo: contribution.memo,
+      })
+      await queryRunner.commitTransaction()
+    } catch (e) {
+      await queryRunner.rollbackTransaction()
+      logger.error(`ContributionMessage was not successful: ${e}`)
+      throw new Error(`ContributionMessage was not successful: ${e}`)
+    } finally {
+      await queryRunner.release()
+    }
+    return new ContributionMessage(contributionMessage, user)
+  }
 }

backend/src/graphql/resolver/ContributionResolver.ts

@@ -1,27 +1,55 @@
-import { RIGHTS } from '@/auth/RIGHTS'
-import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
-import { backendLogger as logger } from '@/server/logger'
-import { Contribution as dbContribution } from '@entity/Contribution'
+import Decimal from 'decimal.js-light'
 import { Arg, Args, Authorized, Ctx, Int, Mutation, Query, Resolver } from 'type-graphql'
-import { FindOperator, IsNull, getConnection } from '@dbTools/typeorm'
-import ContributionArgs from '@arg/ContributionArgs'
-import Paginated from '@arg/Paginated'
+import { FindOperator, IsNull, In, getConnection } from '@dbTools/typeorm'
+
+import { Contribution as DbContribution } from '@entity/Contribution'
+import { ContributionMessage } from '@entity/ContributionMessage'
+import { UserContact } from '@entity/UserContact'
+import { User as DbUser } from '@entity/User'
+import { Transaction as DbTransaction } from '@entity/Transaction'
+
+import { AdminCreateContributions } from '@model/AdminCreateContributions'
+import { AdminUpdateContribution } from '@model/AdminUpdateContribution'
+import { Contribution, ContributionListResult } from '@model/Contribution'
+import { UnconfirmedContribution } from '@model/UnconfirmedContribution'
+import { Decay } from '@model/Decay'
+import { TransactionTypeId } from '@enum/TransactionTypeId'
 import { Order } from '@enum/Order'
 import { ContributionType } from '@enum/ContributionType'
 import { ContributionStatus } from '@enum/ContributionStatus'
-import { Contribution, ContributionListResult } from '@model/Contribution'
-import { UnconfirmedContribution } from '@model/UnconfirmedContribution'
-import { validateContribution, getUserCreation, updateCreations } from './util/creations'
-import { MEMO_MAX_CHARS, MEMO_MIN_CHARS } from './const/const'
-import { ContributionMessage } from '@entity/ContributionMessage'
 import { ContributionMessageType } from '@enum/MessageType'
+import ContributionArgs from '@arg/ContributionArgs'
+import Paginated from '@arg/Paginated'
+import AdminCreateContributionArgs from '@arg/AdminCreateContributionArgs'
+import AdminUpdateContributionArgs from '@arg/AdminUpdateContributionArgs'
+
+import { RIGHTS } from '@/auth/RIGHTS'
+import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
+import { backendLogger as logger } from '@/server/logger'
+import {
+  getUserCreation,
+  getUserCreations,
+  validateContribution,
+  updateCreations,
+  isValidDateString,
+} from './util/creations'
+import { MEMO_MAX_CHARS, MEMO_MIN_CHARS, FULL_CREATION_AVAILABLE } from './const/const'
 import {
   Event,
   EventContributionCreate,
   EventContributionDelete,
   EventContributionUpdate,
+  EventContributionConfirm,
+  EventAdminContributionCreate,
+  EventAdminContributionDelete,
+  EventAdminContributionUpdate,
 } from '@/event/Event'
 import { eventProtocol } from '@/event/EventProtocolEmitter'
+import { calculateDecay } from '@/util/decay'
+import {
+  sendContributionConfirmedEmail,
+  sendContributionRejectedEmail,
+} from '@/emails/sendEmailVariants'
 
 @Resolver()
 export class ContributionResolver {
@@ -50,7 +78,7 @@ export class ContributionResolver {
     const creationDateObj = new Date(creationDate)
     validateContribution(creations, amount, creationDateObj, clientTimezoneOffset)
 
-    const contribution = dbContribution.create()
+    const contribution = DbContribution.create()
     contribution.userId = user.id
     contribution.amount = amount
     contribution.createdAt = new Date()
@@ -60,7 +88,7 @@ export class ContributionResolver {
     contribution.contributionStatus = ContributionStatus.PENDING
 
     logger.trace('contribution to save', contribution)
-    await dbContribution.save(contribution)
+    await DbContribution.save(contribution)
 
     const eventCreateContribution = new EventContributionCreate()
     eventCreateContribution.userId = user.id
@@ -79,7 +107,7 @@ export class ContributionResolver {
   ): Promise<boolean> {
     const event = new Event()
     const user = getUser(context)
-    const contribution = await dbContribution.findOne(id)
+    const contribution = await DbContribution.findOne(id)
     if (!contribution) {
       logger.error('Contribution not found for given id')
       throw new Error('Contribution not found for given id.')
@@ -128,7 +156,7 @@ export class ContributionResolver {
     const [contributions, count] = await getConnection()
       .createQueryBuilder()
       .select('c')
-      .from(dbContribution, 'c')
+      .from(DbContribution, 'c')
       .leftJoinAndSelect('c.messages', 'm')
       .where(where)
       .withDeleted()
@@ -152,7 +180,7 @@ export class ContributionResolver {
     const [dbContributions, count] = await getConnection()
       .createQueryBuilder()
       .select('c')
-      .from(dbContribution, 'c')
+      .from(DbContribution, 'c')
       .innerJoinAndSelect('c.user', 'u')
       .orderBy('c.createdAt', order)
       .limit(pageSize)
@@ -185,7 +213,7 @@ export class ContributionResolver {
 
     const user = getUser(context)
 
-    const contributionToUpdate = await dbContribution.findOne({
+    const contributionToUpdate = await DbContribution.findOne({
       where: { id: contributionId, confirmedAt: IsNull() },
     })
     if (!contributionToUpdate) {
@@ -240,7 +268,7 @@ export class ContributionResolver {
     contributionToUpdate.contributionDate = new Date(creationDate)
     contributionToUpdate.contributionStatus = ContributionStatus.PENDING
     contributionToUpdate.updatedAt = new Date()
-    dbContribution.save(contributionToUpdate)
+    DbContribution.save(contributionToUpdate)
 
     const event = new Event()
 
@@ -252,4 +280,403 @@ export class ContributionResolver {
 
     return new UnconfirmedContribution(contributionToUpdate, user, creations)
   }
+
+  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTION])
+  @Mutation(() => [Number])
+  async adminCreateContribution(
+    @Args() { email, amount, memo, creationDate }: AdminCreateContributionArgs,
+    @Ctx() context: Context,
+  ): Promise<Decimal[]> {
+    logger.info(
+      `adminCreateContribution(email=${email}, amount=${amount}, memo=${memo}, creationDate=${creationDate})`,
+    )
+    const clientTimezoneOffset = getClientTimezoneOffset(context)
+    if (!isValidDateString(creationDate)) {
+      logger.error(`invalid Date for creationDate=${creationDate}`)
+      throw new Error(`invalid Date for creationDate=${creationDate}`)
+    }
+    const emailContact = await UserContact.findOne({
+      where: { email },
+      withDeleted: true,
+      relations: ['user'],
+    })
+    if (!emailContact) {
+      logger.error(`Could not find user with email: ${email}`)
+      throw new Error(`Could not find user with email: ${email}`)
+    }
+    if (emailContact.deletedAt) {
+      logger.error('This emailContact was deleted. Cannot create a contribution.')
+      throw new Error('This emailContact was deleted. Cannot create a contribution.')
+    }
+    if (emailContact.user.deletedAt) {
+      logger.error('This user was deleted. Cannot create a contribution.')
+      throw new Error('This user was deleted. Cannot create a contribution.')
+    }
+    if (!emailContact.emailChecked) {
+      logger.error('Contribution could not be saved, Email is not activated')
+      throw new Error('Contribution could not be saved, Email is not activated')
+    }
+
+    const event = new Event()
+    const moderator = getUser(context)
+    logger.trace('moderator: ', moderator.id)
+    const creations = await getUserCreation(emailContact.userId, clientTimezoneOffset)
+    logger.trace('creations:', creations)
+    const creationDateObj = new Date(creationDate)
+    logger.trace('creationDateObj:', creationDateObj)
+    validateContribution(creations, amount, creationDateObj, clientTimezoneOffset)
+    const contribution = DbContribution.create()
+    contribution.userId = emailContact.userId
+    contribution.amount = amount
+    contribution.createdAt = new Date()
+    contribution.contributionDate = creationDateObj
+    contribution.memo = memo
+    contribution.moderatorId = moderator.id
+    contribution.contributionType = ContributionType.ADMIN
+    contribution.contributionStatus = ContributionStatus.PENDING
+
+    logger.trace('contribution to save', contribution)
+
+    await DbContribution.save(contribution)
+
+    const eventAdminCreateContribution = new EventAdminContributionCreate()
+    eventAdminCreateContribution.userId = moderator.id
+    eventAdminCreateContribution.amount = amount
+    eventAdminCreateContribution.contributionId = contribution.id
+    await eventProtocol.writeEvent(
+      event.setEventAdminContributionCreate(eventAdminCreateContribution),
+    )
+
+    return getUserCreation(emailContact.userId, clientTimezoneOffset)
+  }
+
+  @Authorized([RIGHTS.ADMIN_CREATE_CONTRIBUTIONS])
+  @Mutation(() => AdminCreateContributions)
+  async adminCreateContributions(
+    @Arg('pendingCreations', () => [AdminCreateContributionArgs])
+    contributions: AdminCreateContributionArgs[],
+    @Ctx() context: Context,
+  ): Promise<AdminCreateContributions> {
+    let success = false
+    const successfulContribution: string[] = []
+    const failedContribution: string[] = []
+    for (const contribution of contributions) {
+      await this.adminCreateContribution(contribution, context)
+        .then(() => {
+          successfulContribution.push(contribution.email)
+          success = true
+        })
+        .catch(() => {
+          failedContribution.push(contribution.email)
+        })
+    }
+    return {
+      success,
+      successfulContribution,
+      failedContribution,
+    }
+  }
+
+  @Authorized([RIGHTS.ADMIN_UPDATE_CONTRIBUTION])
+  @Mutation(() => AdminUpdateContribution)
+  async adminUpdateContribution(
+    @Args() { id, email, amount, memo, creationDate }: AdminUpdateContributionArgs,
+    @Ctx() context: Context,
+  ): Promise<AdminUpdateContribution> {
+    const clientTimezoneOffset = getClientTimezoneOffset(context)
+    const emailContact = await UserContact.findOne({
+      where: { email },
+      withDeleted: true,
+      relations: ['user'],
+    })
+    if (!emailContact) {
+      logger.error(`Could not find UserContact with email: ${email}`)
+      throw new Error(`Could not find UserContact with email: ${email}`)
+    }
+    const user = emailContact.user
+    if (!user) {
+      logger.error(`Could not find User to emailContact: ${email}`)
+      throw new Error(`Could not find User to emailContact: ${email}`)
+    }
+    if (user.deletedAt) {
+      logger.error(`User was deleted (${email})`)
+      throw new Error(`User was deleted (${email})`)
+    }
+
+    const moderator = getUser(context)
+
+    const contributionToUpdate = await DbContribution.findOne({
+      where: { id, confirmedAt: IsNull() },
+    })
+    if (!contributionToUpdate) {
+      logger.error('No contribution found to given id.')
+      throw new Error('No contribution found to given id.')
+    }
+
+    if (contributionToUpdate.userId !== user.id) {
+      logger.error('user of the pending contribution and send user does not correspond')
+      throw new Error('user of the pending contribution and send user does not correspond')
+    }
+
+    if (contributionToUpdate.moderatorId === null) {
+      logger.error('An admin is not allowed to update a user contribution.')
+      throw new Error('An admin is not allowed to update a user contribution.')
+    }
+
+    const creationDateObj = new Date(creationDate)
+    let creations = await getUserCreation(user.id, clientTimezoneOffset)
+
+    if (contributionToUpdate.contributionDate.getMonth() === creationDateObj.getMonth()) {
+      creations = updateCreations(creations, contributionToUpdate, clientTimezoneOffset)
+    } else {
+      logger.error('Currently the month of the contribution cannot change.')
+      throw new Error('Currently the month of the contribution cannot change.')
+    }
+
+    // all possible cases not to be true are thrown in this function
+    validateContribution(creations, amount, creationDateObj, clientTimezoneOffset)
+    contributionToUpdate.amount = amount
+    contributionToUpdate.memo = memo
+    contributionToUpdate.contributionDate = new Date(creationDate)
+    contributionToUpdate.moderatorId = moderator.id
+    contributionToUpdate.contributionStatus = ContributionStatus.PENDING
+
+    await DbContribution.save(contributionToUpdate)
+
+    const result = new AdminUpdateContribution()
+    result.amount = amount
+    result.memo = contributionToUpdate.memo
+    result.date = contributionToUpdate.contributionDate
+
+    result.creation = await getUserCreation(user.id, clientTimezoneOffset)
+
+    const event = new Event()
+    const eventAdminContributionUpdate = new EventAdminContributionUpdate()
+    eventAdminContributionUpdate.userId = user.id
+    eventAdminContributionUpdate.amount = amount
+    eventAdminContributionUpdate.contributionId = contributionToUpdate.id
+    await eventProtocol.writeEvent(
+      event.setEventAdminContributionUpdate(eventAdminContributionUpdate),
+    )
+
+    return result
+  }
+
+  @Authorized([RIGHTS.LIST_UNCONFIRMED_CONTRIBUTIONS])
+  @Query(() => [UnconfirmedContribution])
+  async listUnconfirmedContributions(@Ctx() context: Context): Promise<UnconfirmedContribution[]> {
+    const clientTimezoneOffset = getClientTimezoneOffset(context)
+    const contributions = await getConnection()
+      .createQueryBuilder()
+      .select('c')
+      .from(DbContribution, 'c')
+      .leftJoinAndSelect('c.messages', 'm')
+      .where({ confirmedAt: IsNull() })
+      .getMany()
+
+    if (contributions.length === 0) {
+      return []
+    }
+
+    const userIds = contributions.map((p) => p.userId)
+    const userCreations = await getUserCreations(userIds, clientTimezoneOffset)
+    const users = await DbUser.find({
+      where: { id: In(userIds) },
+      withDeleted: true,
+      relations: ['emailContact'],
+    })
+
+    return contributions.map((contribution) => {
+      const user = users.find((u) => u.id === contribution.userId)
+      const creation = userCreations.find((c) => c.id === contribution.userId)
+
+      return new UnconfirmedContribution(
+        contribution,
+        user,
+        creation ? creation.creations : FULL_CREATION_AVAILABLE,
+      )
+    })
+  }
+
+  @Authorized([RIGHTS.ADMIN_DELETE_CONTRIBUTION])
+  @Mutation(() => Boolean)
+  async adminDeleteContribution(
+    @Arg('id', () => Int) id: number,
+    @Ctx() context: Context,
+  ): Promise<boolean> {
+    const contribution = await DbContribution.findOne(id)
+    if (!contribution) {
+      logger.error(`Contribution not found for given id: ${id}`)
+      throw new Error('Contribution not found for given id.')
+    }
+    const moderator = getUser(context)
+    if (
+      contribution.contributionType === ContributionType.USER &&
+      contribution.userId === moderator.id
+    ) {
+      throw new Error('Own contribution can not be deleted as admin')
+    }
+    const user = await DbUser.findOneOrFail(
+      { id: contribution.userId },
+      { relations: ['emailContact'] },
+    )
+    contribution.contributionStatus = ContributionStatus.DELETED
+    contribution.deletedBy = moderator.id
+    await contribution.save()
+    const res = await contribution.softRemove()
+
+    const event = new Event()
+    const eventAdminContributionDelete = new EventAdminContributionDelete()
+    eventAdminContributionDelete.userId = contribution.userId
+    eventAdminContributionDelete.amount = contribution.amount
+    eventAdminContributionDelete.contributionId = contribution.id
+    await eventProtocol.writeEvent(
+      event.setEventAdminContributionDelete(eventAdminContributionDelete),
+    )
+    sendContributionRejectedEmail({
+      firstName: user.firstName,
+      lastName: user.lastName,
+      email: user.emailContact.email,
+      language: user.language,
+      senderFirstName: moderator.firstName,
+      senderLastName: moderator.lastName,
+      contributionMemo: contribution.memo,
+    })
+
+    return !!res
+  }
+
+  @Authorized([RIGHTS.CONFIRM_CONTRIBUTION])
+  @Mutation(() => Boolean)
+  async confirmContribution(
+    @Arg('id', () => Int) id: number,
+    @Ctx() context: Context,
+  ): Promise<boolean> {
+    const clientTimezoneOffset = getClientTimezoneOffset(context)
+    const contribution = await DbContribution.findOne(id)
+    if (!contribution) {
+      logger.error(`Contribution not found for given id: ${id}`)
+      throw new Error('Contribution not found to given id.')
+    }
+    const moderatorUser = getUser(context)
+    if (moderatorUser.id === contribution.userId) {
+      logger.error('Moderator can not confirm own contribution')
+      throw new Error('Moderator can not confirm own contribution')
+    }
+    const user = await DbUser.findOneOrFail(
+      { id: contribution.userId },
+      { withDeleted: true, relations: ['emailContact'] },
+    )
+    if (user.deletedAt) {
+      logger.error('This user was deleted. Cannot confirm a contribution.')
+      throw new Error('This user was deleted. Cannot confirm a contribution.')
+    }
+    const creations = await getUserCreation(contribution.userId, clientTimezoneOffset, false)
+    validateContribution(
+      creations,
+      contribution.amount,
+      contribution.contributionDate,
+      clientTimezoneOffset,
+    )
+
+    const receivedCallDate = new Date()
+
+    const queryRunner = getConnection().createQueryRunner()
+    await queryRunner.connect()
+    await queryRunner.startTransaction('REPEATABLE READ') // 'READ COMMITTED')
+    try {
+      const lastTransaction = await queryRunner.manager
+        .createQueryBuilder()
+        .select('transaction')
+        .from(DbTransaction, 'transaction')
+        .where('transaction.userId = :id', { id: contribution.userId })
+        .orderBy('transaction.balanceDate', 'DESC')
+        .getOne()
+      logger.info('lastTransaction ID', lastTransaction ? lastTransaction.id : 'undefined')
+
+      let newBalance = new Decimal(0)
+      let decay: Decay | null = null
+      if (lastTransaction) {
+        decay = calculateDecay(
+          lastTransaction.balance,
+          lastTransaction.balanceDate,
+          receivedCallDate,
+        )
+        newBalance = decay.balance
+      }
+      newBalance = newBalance.add(contribution.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 = receivedCallDate
+      transaction.decay = decay ? decay.decay : new Decimal(0)
+      transaction.decayStart = decay ? decay.start : null
+      await queryRunner.manager.insert(DbTransaction, transaction)
+
+      contribution.confirmedAt = receivedCallDate
+      contribution.confirmedBy = moderatorUser.id
+      contribution.transactionId = transaction.id
+      contribution.contributionStatus = ContributionStatus.CONFIRMED
+      await queryRunner.manager.update(DbContribution, { id: contribution.id }, contribution)
+
+      await queryRunner.commitTransaction()
+      logger.info('creation commited successfuly.')
+      sendContributionConfirmedEmail({
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.emailContact.email,
+        language: user.language,
+        senderFirstName: moderatorUser.firstName,
+        senderLastName: moderatorUser.lastName,
+        contributionMemo: contribution.memo,
+        contributionAmount: contribution.amount,
+      })
+    } catch (e) {
+      await queryRunner.rollbackTransaction()
+      logger.error(`Creation was not successful: ${e}`)
+      throw new Error(`Creation was not successful.`)
+    } finally {
+      await queryRunner.release()
+    }
+
+    const event = new Event()
+    const eventContributionConfirm = new EventContributionConfirm()
+    eventContributionConfirm.userId = user.id
+    eventContributionConfirm.amount = contribution.amount
+    eventContributionConfirm.contributionId = contribution.id
+    await eventProtocol.writeEvent(event.setEventContributionConfirm(eventContributionConfirm))
+    return true
+  }
+
+  @Authorized([RIGHTS.CREATION_TRANSACTION_LIST])
+  @Query(() => ContributionListResult)
+  async creationTransactionList(
+    @Args()
+    { currentPage = 1, pageSize = 25, order = Order.DESC }: Paginated,
+    @Arg('userId', () => Int) userId: number,
+  ): Promise<ContributionListResult> {
+    const offset = (currentPage - 1) * pageSize
+    const [contributionResult, count] = await getConnection()
+      .createQueryBuilder()
+      .select('c')
+      .from(DbContribution, 'c')
+      .leftJoinAndSelect('c.user', 'u')
+      .where(`user_id = ${userId}`)
+      .limit(pageSize)
+      .offset(offset)
+      .orderBy('c.created_at', order)
+      .getManyAndCount()
+
+    return new ContributionListResult(
+      count,
+      contributionResult.map((contribution) => new Contribution(contribution, contribution.user)),
+    )
+    // return userTransactions.map((t) => new Transaction(t, new User(user), communityUser))
+  }
 }

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

@@ -0,0 +1,126 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+import { testEnvironment, cleanDB } from '@test/helpers'
+import { User as DbUser } from '@entity/User'
+import { createUser, setPassword, forgotPassword } from '@/seeds/graphql/mutations'
+import { queryOptIn } from '@/seeds/graphql/queries'
+import CONFIG from '@/config'
+import { GraphQLError } from 'graphql'
+
+let mutate: any, query: any, con: any
+let testEnv: any
+
+CONFIG.EMAIL_CODE_VALID_TIME = 1440
+CONFIG.EMAIL_CODE_REQUEST_TIME = 10
+CONFIG.EMAIL = false
+
+beforeAll(async () => {
+  testEnv = await testEnvironment()
+  mutate = testEnv.mutate
+  query = testEnv.query
+  con = testEnv.con
+  await cleanDB()
+})
+
+afterAll(async () => {
+  await cleanDB()
+  await con.close()
+})
+
+describe('EmailOptinCodes', () => {
+  let optinCode: string
+  beforeAll(async () => {
+    const variables = {
+      email: 'peter@lustig.de',
+      firstName: 'Peter',
+      lastName: 'Lustig',
+      language: 'de',
+    }
+    const {
+      data: { createUser: user },
+    } = await mutate({ mutation: createUser, variables })
+    const dbObject = await DbUser.findOneOrFail({
+      where: { id: user.id },
+      relations: ['emailContact'],
+    })
+    optinCode = dbObject.emailContact.emailVerificationCode.toString()
+  })
+
+  describe('queryOptIn', () => {
+    it('has a valid optin code', async () => {
+      await expect(
+        query({ query: queryOptIn, variables: { optIn: optinCode } }),
+      ).resolves.toMatchObject({
+        data: {
+          queryOptIn: true,
+        },
+        errors: undefined,
+      })
+    })
+
+    describe('run time forward until code must be expired', () => {
+      beforeAll(() => {
+        jest.useFakeTimers()
+        setTimeout(jest.fn(), CONFIG.EMAIL_CODE_VALID_TIME * 60 * 1000)
+        jest.runAllTimers()
+      })
+
+      afterAll(() => {
+        jest.useRealTimers()
+      })
+
+      it('throws an error', async () => {
+        await expect(
+          query({ query: queryOptIn, variables: { optIn: optinCode } }),
+        ).resolves.toMatchObject({
+          data: null,
+          errors: [new GraphQLError('email was sent more than 24 hours ago')],
+        })
+      })
+
+      it('does not allow to set password', async () => {
+        await expect(
+          mutate({ mutation: setPassword, variables: { code: optinCode, password: 'Aa12345_' } }),
+        ).resolves.toMatchObject({
+          data: null,
+          errors: [new GraphQLError('email was sent more than 24 hours ago')],
+        })
+      })
+    })
+  })
+
+  describe('forgotPassword', () => {
+    it('throws an error', async () => {
+      await expect(
+        mutate({ mutation: forgotPassword, variables: { email: 'peter@lustig.de' } }),
+      ).resolves.toMatchObject({
+        data: null,
+        errors: [new GraphQLError('email already sent less than 10 minutes minutes ago')],
+      })
+    })
+
+    describe('run time forward until code can be resent', () => {
+      beforeAll(() => {
+        jest.useFakeTimers()
+        setTimeout(jest.fn(), CONFIG.EMAIL_CODE_REQUEST_TIME * 60 * 1000)
+        jest.runAllTimers()
+      })
+
+      afterAll(() => {
+        jest.useRealTimers()
+      })
+
+      it('cann send email again', async () => {
+        await expect(
+          mutate({ mutation: forgotPassword, variables: { email: 'peter@lustig.de' } }),
+        ).resolves.toMatchObject({
+          data: {
+            forgotPassword: true,
+          },
+          errors: undefined,
+        })
+      })
+    })
+  })
+})

backend/src/graphql/resolver/GdtResolver.ts

@@ -1,10 +1,12 @@
-import { Context, getUser } from '@/server/context'
 import { Resolver, Query, Args, Ctx, Authorized, Arg } from 'type-graphql'
-import CONFIG from '@/config'
+
 import { GdtEntryList } from '@model/GdtEntryList'
-import Paginated from '@arg/Paginated'
-import { apiGet, apiPost } from '@/apis/HttpRequest'
 import { Order } from '@enum/Order'
+import Paginated from '@arg/Paginated'
+
+import { Context, getUser } from '@/server/context'
+import CONFIG from '@/config'
+import { apiGet, apiPost } from '@/apis/HttpRequest'
 import { RIGHTS } from '@/auth/RIGHTS'
 
 @Resolver()

backend/src/graphql/resolver/KlicktippResolver.ts

@@ -1,4 +1,7 @@
 import { Resolver, Query, Authorized, Arg, Mutation, Args } from 'type-graphql'
+
+import SubscribeNewsletterArgs from '@arg/SubscribeNewsletterArgs'
+
 import {
   getKlickTippUser,
   getKlicktippTagMap,
@@ -6,7 +9,6 @@ import {
   klicktippSignIn,
 } from '@/apis/KlicktippController'
 import { RIGHTS } from '@/auth/RIGHTS'
-import SubscribeNewsletterArgs from '@arg/SubscribeNewsletterArgs'
 
 @Resolver()
 export class KlicktippResolver {

backend/src/graphql/resolver/StatisticsResolver.ts

@@ -1,10 +1,13 @@
-import { Resolver, Query, Authorized } from 'type-graphql'
-import { RIGHTS } from '@/auth/RIGHTS'
-import { CommunityStatistics } from '@model/CommunityStatistics'
-import { User as DbUser } from '@entity/User'
-import { Transaction as DbTransaction } from '@entity/Transaction'
-import { getConnection } from '@dbTools/typeorm'
 import Decimal from 'decimal.js-light'
+import { Resolver, Query, Authorized } from 'type-graphql'
+import { getConnection } from '@dbTools/typeorm'
+
+import { Transaction as DbTransaction } from '@entity/Transaction'
+import { User as DbUser } from '@entity/User'
+
+import { CommunityStatistics } from '@model/CommunityStatistics'
+
+import { RIGHTS } from '@/auth/RIGHTS'
 import { calculateDecay } from '@/util/decay'
 
 /* eslint-disable @typescript-eslint/no-explicit-any */

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

@@ -4,8 +4,12 @@
 import { transactionLinkCode } from './TransactionLinkResolver'
 import { bibiBloxberg } from '@/seeds/users/bibi-bloxberg'
 import { peterLustig } from '@/seeds/users/peter-lustig'
-import { cleanDB, testEnvironment } from '@test/helpers'
+import { cleanDB, testEnvironment, resetToken } from '@test/helpers'
+import { creationFactory } from '@/seeds/factory/creation'
+import { creations } from '@/seeds/creation/index'
 import { userFactory } from '@/seeds/factory/user'
+import { transactionLinkFactory } from '@/seeds/factory/transactionLink'
+import { transactionLinks } from '@/seeds/transactionLink/index'
 import {
   login,
   createContributionLink,
@@ -13,17 +17,22 @@ import {
   createContribution,
   updateContribution,
 } from '@/seeds/graphql/mutations'
+import { listTransactionLinksAdmin } from '@/seeds/graphql/queries'
 import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+import { User } from '@entity/User'
 import { UnconfirmedContribution } from '@model/UnconfirmedContribution'
 import Decimal from 'decimal.js-light'
 import { GraphQLError } from 'graphql'
 
-let mutate: any, con: any
+let mutate: any, query: any, con: any
 let testEnv: any
 
+let user: User
+
 beforeAll(async () => {
   testEnv = await testEnvironment()
   mutate = testEnv.mutate
+  query = testEnv.query
   con = testEnv.con
   await cleanDB()
   await userFactory(testEnv, bibiBloxberg)
@@ -36,6 +45,7 @@ afterAll(async () => {
 })
 
 describe('TransactionLinkResolver', () => {
+  // TODO: have this test separated into a transactionLink and a contributionLink part (if possible)
   describe('redeem daily Contribution Link', () => {
     const now = new Date()
     let contributionLink: DbContributionLink | undefined
@@ -223,6 +233,274 @@ describe('TransactionLinkResolver', () => {
       })
     })
   })
+
+  describe('transaction links list', () => {
+    const variables = {
+      userId: 1, // dummy, may be replaced
+      filters: null,
+      currentPage: 1,
+      pageSize: 5,
+    }
+
+    // TODO: there is a test not cleaning up after itself! Fix it!
+    beforeAll(async () => {
+      await cleanDB()
+      resetToken()
+    })
+
+    describe('unauthenticated', () => {
+      it('returns an error', async () => {
+        await expect(
+          query({
+            query: listTransactionLinksAdmin,
+            variables,
+          }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('authenticated', () => {
+      describe('without admin rights', () => {
+        beforeAll(async () => {
+          user = await userFactory(testEnv, bibiBloxberg)
+          await mutate({
+            mutation: login,
+            variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        it('returns an error', async () => {
+          await expect(
+            query({
+              query: listTransactionLinksAdmin,
+              variables,
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('with admin rights', () => {
+        beforeAll(async () => {
+          // admin 'peter@lustig.de' has to exists for 'creationFactory'
+          await userFactory(testEnv, peterLustig)
+
+          user = await userFactory(testEnv, bibiBloxberg)
+          variables.userId = user.id
+          variables.pageSize = 25
+          // bibi needs GDDs
+          const bibisCreation = creations.find((creation) => creation.email === 'bibi@bloxberg.de')
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          await creationFactory(testEnv, bibisCreation!)
+          // bibis transaktion links
+          const bibisTransaktionLinks = transactionLinks.filter(
+            (transactionLink) => transactionLink.email === 'bibi@bloxberg.de',
+          )
+          for (let i = 0; i < bibisTransaktionLinks.length; i++) {
+            await transactionLinkFactory(testEnv, bibisTransaktionLinks[i])
+          }
+
+          // admin: only now log in
+          await mutate({
+            mutation: login,
+            variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        describe('without any filters', () => {
+          it('finds 6 open transaction links and no deleted or redeemed', async () => {
+            await expect(
+              query({
+                query: listTransactionLinksAdmin,
+                variables,
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listTransactionLinksAdmin: {
+                    linkCount: 6,
+                    linkList: expect.not.arrayContaining([
+                      expect.objectContaining({
+                        memo: 'Leider wollte niemand meine Gradidos zum Neujahr haben :(',
+                        createdAt: expect.any(String),
+                      }),
+                      expect.objectContaining({
+                        memo: 'Da habe ich mich wohl etwas übernommen.',
+                        deletedAt: expect.any(String),
+                      }),
+                    ]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('all filters are null', () => {
+          it('finds 6 open transaction links and no deleted or redeemed', async () => {
+            await expect(
+              query({
+                query: listTransactionLinksAdmin,
+                variables: {
+                  ...variables,
+                  filters: {
+                    withDeleted: null,
+                    withExpired: null,
+                    withRedeemed: null,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listTransactionLinksAdmin: {
+                    linkCount: 6,
+                    linkList: expect.not.arrayContaining([
+                      expect.objectContaining({
+                        memo: 'Leider wollte niemand meine Gradidos zum Neujahr haben :(',
+                        createdAt: expect.any(String),
+                      }),
+                      expect.objectContaining({
+                        memo: 'Da habe ich mich wohl etwas übernommen.',
+                        deletedAt: expect.any(String),
+                      }),
+                    ]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('filter with deleted', () => {
+          it('finds 6 open transaction links, 1 deleted, and no redeemed', async () => {
+            await expect(
+              query({
+                query: listTransactionLinksAdmin,
+                variables: {
+                  ...variables,
+                  filters: {
+                    withDeleted: true,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listTransactionLinksAdmin: {
+                    linkCount: 7,
+                    linkList: expect.arrayContaining([
+                      expect.not.objectContaining({
+                        memo: 'Leider wollte niemand meine Gradidos zum Neujahr haben :(',
+                        createdAt: expect.any(String),
+                      }),
+                      expect.objectContaining({
+                        memo: 'Da habe ich mich wohl etwas übernommen.',
+                        deletedAt: expect.any(String),
+                      }),
+                    ]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('filter by expired', () => {
+          it('finds 5 open transaction links, 1 expired, and no redeemed', async () => {
+            await expect(
+              query({
+                query: listTransactionLinksAdmin,
+                variables: {
+                  ...variables,
+                  filters: {
+                    withExpired: true,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listTransactionLinksAdmin: {
+                    linkCount: 7,
+                    linkList: expect.arrayContaining([
+                      expect.objectContaining({
+                        memo: 'Leider wollte niemand meine Gradidos zum Neujahr haben :(',
+                        createdAt: expect.any(String),
+                      }),
+                      expect.not.objectContaining({
+                        memo: 'Da habe ich mich wohl etwas übernommen.',
+                        deletedAt: expect.any(String),
+                      }),
+                    ]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        // TODO: works not as expected, because 'redeemedAt' and 'redeemedBy' have to be added to the transaktion link factory
+        describe.skip('filter by redeemed', () => {
+          it('finds 6 open transaction links, 1 deleted, and no redeemed', async () => {
+            await expect(
+              query({
+                query: listTransactionLinksAdmin,
+                variables: {
+                  ...variables,
+                  filters: {
+                    withDeleted: null,
+                    withExpired: null,
+                    withRedeemed: true,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  listTransactionLinksAdmin: {
+                    linkCount: 6,
+                    linkList: expect.arrayContaining([
+                      expect.not.objectContaining({
+                        memo: 'Leider wollte niemand meine Gradidos zum Neujahr haben :(',
+                        createdAt: expect.any(String),
+                      }),
+                      expect.objectContaining({
+                        memo: 'Yeah, eingelöst!',
+                        redeemedAt: expect.any(String),
+                        redeemedBy: expect.any(Number),
+                      }),
+                      expect.not.objectContaining({
+                        memo: 'Da habe ich mich wohl etwas übernommen.',
+                        deletedAt: expect.any(String),
+                      }),
+                    ]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+      })
+    })
+  })
 })
 
 describe('transactionLinkCode', () => {

backend/src/graphql/resolver/TransactionLinkResolver.ts

@@ -1,45 +1,36 @@
-import { backendLogger as logger } from '@/server/logger'
-import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
-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'
-import { calculateBalance } from '@/util/validate'
-import { RIGHTS } from '@/auth/RIGHTS'
 import { randomBytes } from 'crypto'
+import Decimal from 'decimal.js-light'
+
+import { getConnection, MoreThan, FindOperator } from '@dbTools/typeorm'
+
+import { TransactionLink as DbTransactionLink } from '@entity/TransactionLink'
+import { User as DbUser } from '@entity/User'
+import { Transaction as DbTransaction } from '@entity/Transaction'
+import { Contribution as DbContribution } from '@entity/Contribution'
+import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+
 import { User } from '@model/User'
-import { calculateDecay } from '@/util/decay'
-import { executeTransaction } from './TransactionResolver'
+import { ContributionLink } from '@model/ContributionLink'
+import { Decay } from '@model/Decay'
+import { TransactionLink, TransactionLinkResult } from '@model/TransactionLink'
 import { Order } from '@enum/Order'
 import { ContributionType } from '@enum/ContributionType'
 import { ContributionStatus } from '@enum/ContributionStatus'
-import { Contribution as DbContribution } from '@entity/Contribution'
-import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
-import { getUserCreation, validateContribution } from './util/creations'
-import { Decay } from '@model/Decay'
-import Decimal from 'decimal.js-light'
 import { TransactionTypeId } from '@enum/TransactionTypeId'
 import { ContributionCycleType } from '@enum/ContributionCycleType'
+import TransactionLinkArgs from '@arg/TransactionLinkArgs'
+import Paginated from '@arg/Paginated'
+import TransactionLinkFilters from '@arg/TransactionLinkFilters'
 
-const QueryLinkResult = createUnionType({
-  name: 'QueryLinkResult', // the name of the GraphQL union
-  types: () => [TransactionLink, ContributionLink] as const, // function that returns tuple of object types classes
-})
+import { backendLogger as logger } from '@/server/logger'
+import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
+import { Resolver, Args, Arg, Authorized, Ctx, Mutation, Query, Int } from 'type-graphql'
+import { calculateBalance } from '@/util/validate'
+import { RIGHTS } from '@/auth/RIGHTS'
+import { calculateDecay } from '@/util/decay'
+import { getUserCreation, validateContribution } from './util/creations'
+import { executeTransaction } from './TransactionResolver'
+import QueryLinkResult from '@union/QueryLinkResult'
 
 // TODO: do not export, test it inside the resolver
 export const transactionLinkCode = (date: Date): string => {
@@ -79,7 +70,7 @@ export class TransactionLinkResolver {
       throw new Error("user hasn't enough GDD or amount is < 0")
     }
 
-    const transactionLink = dbTransactionLink.create()
+    const transactionLink = DbTransactionLink.create()
     transactionLink.userId = user.id
     transactionLink.amount = amount
     transactionLink.memo = memo
@@ -87,7 +78,7 @@ export class TransactionLinkResolver {
     transactionLink.code = transactionLinkCode(createdDate)
     transactionLink.createdAt = createdDate
     transactionLink.validUntil = validUntil
-    await dbTransactionLink.save(transactionLink).catch(() => {
+    await DbTransactionLink.save(transactionLink).catch(() => {
       throw new Error('Unable to save transaction link')
     })
 
@@ -102,7 +93,7 @@ export class TransactionLinkResolver {
   ): Promise<boolean> {
     const user = getUser(context)
 
-    const transactionLink = await dbTransactionLink.findOne({ id })
+    const transactionLink = await DbTransactionLink.findOne({ id })
     if (!transactionLink) {
       throw new Error('Transaction Link not found!')
     }
@@ -132,11 +123,11 @@ export class TransactionLinkResolver {
       )
       return new ContributionLink(contributionLink)
     } else {
-      const transactionLink = await dbTransactionLink.findOneOrFail({ code }, { withDeleted: true })
-      const user = await dbUser.findOneOrFail({ id: transactionLink.userId })
+      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 }))
+        redeemedBy = new User(await DbUser.findOneOrFail({ id: transactionLink.redeemedBy }))
       }
       return new TransactionLink(transactionLink, new User(user), redeemedBy)
     }
@@ -151,7 +142,7 @@ export class TransactionLinkResolver {
   ): Promise<TransactionLink[]> {
     const user = getUser(context)
     // const now = new Date()
-    const transactionLinks = await dbTransactionLink.find({
+    const transactionLinks = await DbTransactionLink.find({
       where: {
         userId: user.id,
         redeemedBy: null,
@@ -321,8 +312,8 @@ export class TransactionLinkResolver {
       }
       return true
     } else {
-      const transactionLink = await dbTransactionLink.findOneOrFail({ code })
-      const linkedUser = await dbUser.findOneOrFail(
+      const transactionLink = await DbTransactionLink.findOneOrFail({ code })
+      const linkedUser = await DbUser.findOneOrFail(
         { id: transactionLink.userId },
         { relations: ['emailContact'] },
       )
@@ -350,4 +341,44 @@ export class TransactionLinkResolver {
       return true
     }
   }
+
+  @Authorized([RIGHTS.LIST_TRANSACTION_LINKS_ADMIN])
+  @Query(() => TransactionLinkResult)
+  async listTransactionLinksAdmin(
+    @Args()
+    { currentPage = 1, pageSize = 5, order = Order.DESC }: Paginated,
+    @Arg('filters', () => TransactionLinkFilters, { nullable: true })
+    filters: TransactionLinkFilters,
+    @Arg('userId', () => Int)
+    userId: number,
+  ): Promise<TransactionLinkResult> {
+    const user = await DbUser.findOneOrFail({ id: userId })
+    const where: {
+      userId: number
+      redeemedBy?: number | null
+      validUntil?: FindOperator<Date> | null
+    } = {
+      userId,
+      redeemedBy: null,
+      validUntil: MoreThan(new Date()),
+    }
+    if (filters) {
+      if (filters.withRedeemed) delete where.redeemedBy
+      if (filters.withExpired) delete where.validUntil
+    }
+    const [transactionLinks, count] = await DbTransactionLink.findAndCount({
+      where,
+      withDeleted: filters ? filters.withDeleted : false,
+      order: {
+        createdAt: order,
+      },
+      skip: (currentPage - 1) * pageSize,
+      take: pageSize,
+    })
+
+    return {
+      linkCount: count,
+      linkList: transactionLinks.map((tl) => new TransactionLink(tl, new User(user))),
+    }
+  }
 }

backend/src/graphql/resolver/TransactionResolver.ts

@@ -1,44 +1,40 @@
 /* eslint-disable new-cap */
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-import { backendLogger as logger } from '@/server/logger'
-import CONFIG from '@/config'
-
-import { Context, getUser } from '@/server/context'
+import Decimal from 'decimal.js-light'
 import { Resolver, Query, Args, Authorized, Ctx, Mutation } from 'type-graphql'
 import { getCustomRepository, getConnection, In } from '@dbTools/typeorm'
 
-import { sendTransactionReceivedEmail } from '@/mailer/sendTransactionReceivedEmail'
-
-import { Transaction } from '@model/Transaction'
-import { TransactionList } from '@model/TransactionList'
-
-import TransactionSendArgs from '@arg/TransactionSendArgs'
-import Paginated from '@arg/Paginated'
-
-import { Order } from '@enum/Order'
-
-import { TransactionRepository } from '@repository/Transaction'
-import { TransactionLinkRepository } from '@repository/TransactionLink'
-
 import { User as dbUser } from '@entity/User'
 import { Transaction as dbTransaction } from '@entity/Transaction'
 import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
+import { TransactionRepository } from '@repository/Transaction'
+import { TransactionLinkRepository } from '@repository/TransactionLink'
 
+import { User } from '@model/User'
+import { Transaction } from '@model/Transaction'
+import { TransactionList } from '@model/TransactionList'
+import { Order } from '@enum/Order'
 import { TransactionTypeId } from '@enum/TransactionTypeId'
+import TransactionSendArgs from '@arg/TransactionSendArgs'
+import Paginated from '@arg/Paginated'
+
+import { backendLogger as logger } from '@/server/logger'
+import { Context, getUser } from '@/server/context'
 import { calculateBalance, isHexPublicKey } from '@/util/validate'
 import { RIGHTS } from '@/auth/RIGHTS'
-import { User } from '@model/User'
 import { communityUser } from '@/util/communityUser'
 import { virtualLinkTransaction, virtualDecayTransaction } from '@/util/virtualTransactions'
-import Decimal from 'decimal.js-light'
+import {
+  sendTransactionLinkRedeemedEmail,
+  sendTransactionReceivedEmail,
+} from '@/emails/sendEmailVariants'
+import { Event, EventTransactionReceive, EventTransactionSend } from '@/event/Event'
+import { eventProtocol } from '@/event/EventProtocolEmitter'
 
 import { BalanceResolver } from './BalanceResolver'
 import { MEMO_MAX_CHARS, MEMO_MIN_CHARS } from './const/const'
 import { findUserByEmail } from './UserResolver'
-import { sendTransactionLinkRedeemedEmail } from '@/mailer/sendTransactionLinkRedeemed'
-import { Event, EventTransactionReceive, EventTransactionSend } from '@/event/Event'
-import { eventProtocol } from '@/event/EventProtocolEmitter'
 
 export const executeTransaction = async (
   amount: Decimal,
@@ -159,29 +155,27 @@ export const executeTransaction = async (
     await queryRunner.release()
   }
   logger.debug(`prepare Email for transaction received...`)
-  // send notification email
-  // TODO: translate
   await sendTransactionReceivedEmail({
+    firstName: recipient.firstName,
+    lastName: recipient.lastName,
+    email: recipient.emailContact.email,
+    language: recipient.language,
     senderFirstName: sender.firstName,
     senderLastName: sender.lastName,
-    recipientFirstName: recipient.firstName,
-    recipientLastName: recipient.lastName,
-    email: recipient.emailContact.email,
     senderEmail: sender.emailContact.email,
-    amount,
-    overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+    transactionAmount: amount,
   })
   if (transactionLink) {
     await sendTransactionLinkRedeemedEmail({
+      firstName: sender.firstName,
+      lastName: sender.lastName,
+      email: sender.emailContact.email,
+      language: sender.language,
       senderFirstName: recipient.firstName,
       senderLastName: recipient.lastName,
-      recipientFirstName: sender.firstName,
-      recipientLastName: sender.lastName,
-      email: sender.emailContact.email,
       senderEmail: recipient.emailContact.email,
-      amount,
-      memo,
-      overviewURL: CONFIG.EMAIL_LINK_OVERVIEW,
+      transactionAmount: amount,
+      transactionMemo: memo,
     })
   }
   logger.info(`finished executeTransaction successfully`)

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

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 
+import { objectValuesToArray } from '@/util/utilities'
 import { testEnvironment, headerPushMock, resetToken, cleanDB } from '@test/helpers'
+import { logger, i18n as localization } from '@test/testSetup'
+import { printTimeDuration } from '@/util/time'
 import { userFactory } from '@/seeds/factory/user'
 import { bibiBloxberg } from '@/seeds/users/bibi-bloxberg'
 import {
@@ -13,53 +16,49 @@ import {
   updateUserInfos,
   createContribution,
   confirmContribution,
+  setUserRole,
+  deleteUser,
+  unDeleteUser,
 } from '@/seeds/graphql/mutations'
-import { verifyLogin, queryOptIn, searchAdminUsers } from '@/seeds/graphql/queries'
+import { verifyLogin, queryOptIn, searchAdminUsers, searchUsers } from '@/seeds/graphql/queries'
 import { GraphQLError } from 'graphql'
 import { User } from '@entity/User'
 import CONFIG from '@/config'
-import { sendAccountActivationEmail } from '@/mailer/sendAccountActivationEmail'
-import { sendAccountMultiRegistrationEmail } from '@/emails/sendEmailVariants'
-import { sendResetPasswordEmail } from '@/mailer/sendResetPasswordEmail'
-import { printTimeDuration, activationLink } from './UserResolver'
+import {
+  sendAccountActivationEmail,
+  sendAccountMultiRegistrationEmail,
+  sendResetPasswordEmail,
+} from '@/emails/sendEmailVariants'
 import { contributionLinkFactory } from '@/seeds/factory/contributionLink'
 import { transactionLinkFactory } from '@/seeds/factory/transactionLink'
 import { ContributionLink } from '@model/ContributionLink'
 import { TransactionLink } from '@entity/TransactionLink'
-
 import { EventProtocolType } from '@/event/EventProtocolType'
 import { EventProtocol } from '@entity/EventProtocol'
-import { logger, i18n as localization } from '@test/testSetup'
 import { validate as validateUUID, version as versionUUID } from 'uuid'
 import { peterLustig } from '@/seeds/users/peter-lustig'
 import { UserContact } from '@entity/UserContact'
 import { OptInType } from '../enum/OptInType'
 import { UserContactType } from '../enum/UserContactType'
 import { bobBaumeister } from '@/seeds/users/bob-baumeister'
+import { stephenHawking } from '@/seeds/users/stephen-hawking'
+import { garrickOllivander } from '@/seeds/users/garrick-ollivander'
 import { encryptPassword } from '@/password/PasswordEncryptor'
 import { PasswordEncryptionType } from '../enum/PasswordEncryptionType'
 import { SecretKeyCryptographyCreateKey } from '@/password/EncryptorUtils'
 
 // import { klicktippSignIn } from '@/apis/KlicktippController'
 
-jest.mock('@/mailer/sendAccountActivationEmail', () => {
-  return {
-    __esModule: true,
-    sendAccountActivationEmail: jest.fn(),
-  }
-})
-
 jest.mock('@/emails/sendEmailVariants', () => {
+  const originalModule = jest.requireActual('@/emails/sendEmailVariants')
   return {
     __esModule: true,
-    sendAccountMultiRegistrationEmail: jest.fn(),
-  }
-})
-
-jest.mock('@/mailer/sendResetPasswordEmail', () => {
-  return {
-    __esModule: true,
-    sendResetPasswordEmail: jest.fn(),
+    ...originalModule,
+    sendAccountActivationEmail: jest.fn((a) => originalModule.sendAccountActivationEmail(a)),
+    sendAccountMultiRegistrationEmail: jest.fn((a) =>
+      originalModule.sendAccountMultiRegistrationEmail(a),
+    ),
+    sendResetPasswordEmail: jest.fn((a) => originalModule.sendResetPasswordEmail(a)),
   }
 })
 
@@ -72,6 +71,8 @@ jest.mock('@/apis/KlicktippController', () => {
 })
 */
 
+let admin: User
+let user: User
 let mutate: any, query: any, con: any
 let testEnv: any
 
@@ -184,11 +185,15 @@ describe('UserResolver', () => {
           emailVerificationCode,
         ).replace(/{code}/g, '')
         expect(sendAccountActivationEmail).toBeCalledWith({
-          link: activationLink,
           firstName: 'Peter',
           lastName: 'Lustig',
           email: 'peter@lustig.de',
-          duration: expect.any(String),
+          language: 'de',
+          activationLink,
+          timeDurationObject: expect.objectContaining({
+            hours: expect.any(Number),
+            minutes: expect.any(Number),
+          }),
         })
       })
 
@@ -809,12 +814,8 @@ describe('UserResolver', () => {
     })
 
     describe('user exists in DB', () => {
-      let emailContact: UserContact
-
       beforeAll(async () => {
         await userFactory(testEnv, bibiBloxberg)
-        // await resetEntity(LoginEmailOptIn)
-        emailContact = await UserContact.findOneOrFail(variables)
       })
 
       afterAll(async () => {
@@ -823,7 +824,7 @@ describe('UserResolver', () => {
       })
 
       describe('duration not expired', () => {
-        it('returns true', async () => {
+        it('throws an error', async () => {
           await expect(mutate({ mutation: forgotPassword, variables })).resolves.toEqual(
             expect.objectContaining({
               errors: [
@@ -849,15 +850,19 @@ describe('UserResolver', () => {
             }),
           )
         })
-      })
 
-      it('sends reset password email', () => {
-        expect(sendResetPasswordEmail).toBeCalledWith({
-          link: activationLink(emailContact.emailVerificationCode),
-          firstName: 'Bibi',
-          lastName: 'Bloxberg',
-          email: 'bibi@bloxberg.de',
-          duration: expect.any(String),
+        it('sends reset password email', () => {
+          expect(sendResetPasswordEmail).toBeCalledWith({
+            firstName: 'Bibi',
+            lastName: 'Bloxberg',
+            email: 'bibi@bloxberg.de',
+            language: 'de',
+            resetLink: expect.any(String),
+            timeDurationObject: expect.objectContaining({
+              hours: expect.any(Number),
+              minutes: expect.any(Number),
+            }),
+          })
         })
       })
 
@@ -1251,6 +1256,635 @@ describe('UserResolver', () => {
       })
     })
   })
+
+  describe('set user role', () => {
+    // TODO: there is a test not cleaning up after itself! Fix it!
+    beforeAll(async () => {
+      await cleanDB()
+      resetToken()
+    })
+
+    describe('unauthenticated', () => {
+      it('returns an error', async () => {
+        await expect(
+          mutate({ mutation: setUserRole, variables: { userId: 1, isAdmin: true } }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('authenticated', () => {
+      describe('without admin rights', () => {
+        beforeAll(async () => {
+          user = await userFactory(testEnv, bibiBloxberg)
+          await mutate({
+            mutation: login,
+            variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        it('returns an error', async () => {
+          await expect(
+            mutate({ mutation: setUserRole, variables: { userId: user.id + 1, isAdmin: true } }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('with admin rights', () => {
+        beforeAll(async () => {
+          admin = await userFactory(testEnv, peterLustig)
+          await mutate({
+            mutation: login,
+            variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        describe('user to get a new role does not exist', () => {
+          it('throws an error', async () => {
+            jest.clearAllMocks()
+            await expect(
+              mutate({ mutation: setUserRole, variables: { userId: admin.id + 1, isAdmin: true } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError(`Could not find user with userId: ${admin.id + 1}`)],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith(`Could not find user with userId: ${admin.id + 1}`)
+          })
+        })
+
+        describe('change role with success', () => {
+          beforeAll(async () => {
+            user = await userFactory(testEnv, bibiBloxberg)
+          })
+
+          describe('user gets new role', () => {
+            describe('to admin', () => {
+              it('returns date string', async () => {
+                const result = await mutate({
+                  mutation: setUserRole,
+                  variables: { userId: user.id, isAdmin: true },
+                })
+                expect(result).toEqual(
+                  expect.objectContaining({
+                    data: {
+                      setUserRole: expect.any(String),
+                    },
+                  }),
+                )
+                expect(new Date(result.data.setUserRole)).toEqual(expect.any(Date))
+              })
+            })
+
+            describe('to usual user', () => {
+              it('returns null', async () => {
+                await expect(
+                  mutate({ mutation: setUserRole, variables: { userId: user.id, isAdmin: false } }),
+                ).resolves.toEqual(
+                  expect.objectContaining({
+                    data: {
+                      setUserRole: null,
+                    },
+                  }),
+                )
+              })
+            })
+          })
+        })
+
+        describe('change role with error', () => {
+          describe('is own role', () => {
+            it('throws an error', async () => {
+              jest.clearAllMocks()
+              await expect(
+                mutate({ mutation: setUserRole, variables: { userId: admin.id, isAdmin: false } }),
+              ).resolves.toEqual(
+                expect.objectContaining({
+                  errors: [new GraphQLError('Administrator can not change his own role!')],
+                }),
+              )
+            })
+            it('logs the error thrown', () => {
+              expect(logger.error).toBeCalledWith('Administrator can not change his own role!')
+            })
+          })
+
+          describe('user has already role to be set', () => {
+            describe('to admin', () => {
+              it('throws an error', async () => {
+                jest.clearAllMocks()
+                await mutate({
+                  mutation: setUserRole,
+                  variables: { userId: user.id, isAdmin: true },
+                })
+                await expect(
+                  mutate({ mutation: setUserRole, variables: { userId: user.id, isAdmin: true } }),
+                ).resolves.toEqual(
+                  expect.objectContaining({
+                    errors: [new GraphQLError('User is already admin!')],
+                  }),
+                )
+              })
+
+              it('logs the error thrown', () => {
+                expect(logger.error).toBeCalledWith('User is already admin!')
+              })
+            })
+
+            describe('to usual user', () => {
+              it('throws an error', async () => {
+                jest.clearAllMocks()
+                await mutate({
+                  mutation: setUserRole,
+                  variables: { userId: user.id, isAdmin: false },
+                })
+                await expect(
+                  mutate({ mutation: setUserRole, variables: { userId: user.id, isAdmin: false } }),
+                ).resolves.toEqual(
+                  expect.objectContaining({
+                    errors: [new GraphQLError('User is already a usual user!')],
+                  }),
+                )
+              })
+
+              it('logs the error thrown', () => {
+                expect(logger.error).toBeCalledWith('User is already a usual user!')
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+
+  describe('delete user', () => {
+    describe('unauthenticated', () => {
+      it('returns an error', async () => {
+        await expect(mutate({ mutation: deleteUser, variables: { userId: 1 } })).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('authenticated', () => {
+      describe('without admin rights', () => {
+        beforeAll(async () => {
+          user = await userFactory(testEnv, bibiBloxberg)
+          await mutate({
+            mutation: login,
+            variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        it('returns an error', async () => {
+          await expect(
+            mutate({ mutation: deleteUser, variables: { userId: user.id + 1 } }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('with admin rights', () => {
+        beforeAll(async () => {
+          admin = await userFactory(testEnv, peterLustig)
+          await mutate({
+            mutation: login,
+            variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        describe('user to be deleted does not exist', () => {
+          it('throws an error', async () => {
+            jest.clearAllMocks()
+            await expect(
+              mutate({ mutation: deleteUser, variables: { userId: admin.id + 1 } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError(`Could not find user with userId: ${admin.id + 1}`)],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith(`Could not find user with userId: ${admin.id + 1}`)
+          })
+        })
+
+        describe('delete self', () => {
+          it('throws an error', async () => {
+            jest.clearAllMocks()
+            await expect(
+              mutate({ mutation: deleteUser, variables: { userId: admin.id } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError('Moderator can not delete his own account!')],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith('Moderator can not delete his own account!')
+          })
+        })
+
+        describe('delete with success', () => {
+          beforeAll(async () => {
+            user = await userFactory(testEnv, bibiBloxberg)
+          })
+
+          it('returns date string', async () => {
+            const result = await mutate({ mutation: deleteUser, variables: { userId: user.id } })
+            expect(result).toEqual(
+              expect.objectContaining({
+                data: {
+                  deleteUser: expect.any(String),
+                },
+              }),
+            )
+            expect(new Date(result.data.deleteUser)).toEqual(expect.any(Date))
+          })
+
+          describe('delete deleted user', () => {
+            it('throws an error', async () => {
+              jest.clearAllMocks()
+              await expect(
+                mutate({ mutation: deleteUser, variables: { userId: user.id } }),
+              ).resolves.toEqual(
+                expect.objectContaining({
+                  errors: [new GraphQLError(`Could not find user with userId: ${user.id}`)],
+                }),
+              )
+            })
+
+            it('logs the error thrown', () => {
+              expect(logger.error).toBeCalledWith(`Could not find user with userId: ${user.id}`)
+            })
+          })
+        })
+      })
+    })
+  })
+
+  describe('unDelete user', () => {
+    describe('unauthenticated', () => {
+      it('returns an error', async () => {
+        await expect(mutate({ mutation: unDeleteUser, variables: { userId: 1 } })).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('authenticated', () => {
+      describe('without admin rights', () => {
+        beforeAll(async () => {
+          user = await userFactory(testEnv, bibiBloxberg)
+          await mutate({
+            mutation: login,
+            variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        it('returns an error', async () => {
+          await expect(
+            mutate({ mutation: unDeleteUser, variables: { userId: user.id + 1 } }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('with admin rights', () => {
+        beforeAll(async () => {
+          admin = await userFactory(testEnv, peterLustig)
+          await mutate({
+            mutation: login,
+            variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        describe('user to be undelete does not exist', () => {
+          it('throws an error', async () => {
+            jest.clearAllMocks()
+            await expect(
+              mutate({ mutation: unDeleteUser, variables: { userId: admin.id + 1 } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError(`Could not find user with userId: ${admin.id + 1}`)],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith(`Could not find user with userId: ${admin.id + 1}`)
+          })
+        })
+
+        describe('user to undelete is not deleted', () => {
+          beforeAll(async () => {
+            user = await userFactory(testEnv, bibiBloxberg)
+          })
+
+          it('throws an error', async () => {
+            jest.clearAllMocks()
+            await expect(
+              mutate({ mutation: unDeleteUser, variables: { userId: user.id } }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                errors: [new GraphQLError('User is not deleted')],
+              }),
+            )
+          })
+
+          it('logs the error thrown', () => {
+            expect(logger.error).toBeCalledWith('User is not deleted')
+          })
+
+          describe('undelete deleted user', () => {
+            beforeAll(async () => {
+              await mutate({ mutation: deleteUser, variables: { userId: user.id } })
+            })
+
+            it('returns null', async () => {
+              await expect(
+                mutate({ mutation: unDeleteUser, variables: { userId: user.id } }),
+              ).resolves.toEqual(
+                expect.objectContaining({
+                  data: { unDeleteUser: null },
+                }),
+              )
+            })
+          })
+        })
+      })
+    })
+  })
+
+  describe('search users', () => {
+    const variablesWithoutTextAndFilters = {
+      searchText: '',
+      currentPage: 1,
+      pageSize: 25,
+      filters: null,
+    }
+
+    describe('unauthenticated', () => {
+      it('returns an error', async () => {
+        await expect(
+          query({
+            query: searchUsers,
+            variables: {
+              ...variablesWithoutTextAndFilters,
+            },
+          }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('401 Unauthorized')],
+          }),
+        )
+      })
+    })
+
+    describe('authenticated', () => {
+      describe('without admin rights', () => {
+        beforeAll(async () => {
+          user = await userFactory(testEnv, bibiBloxberg)
+          await mutate({
+            mutation: login,
+            variables: { email: 'bibi@bloxberg.de', password: 'Aa12345_' },
+          })
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        it('returns an error', async () => {
+          await expect(
+            query({
+              query: searchUsers,
+              variables: {
+                ...variablesWithoutTextAndFilters,
+              },
+            }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              errors: [new GraphQLError('401 Unauthorized')],
+            }),
+          )
+        })
+      })
+
+      describe('with admin rights', () => {
+        const allUsers = {
+          bibi: expect.objectContaining({
+            email: 'bibi@bloxberg.de',
+          }),
+          garrick: expect.objectContaining({
+            email: 'garrick@ollivander.com',
+          }),
+          peter: expect.objectContaining({
+            email: 'peter@lustig.de',
+          }),
+          stephen: expect.objectContaining({
+            email: 'stephen@hawking.uk',
+          }),
+        }
+
+        beforeAll(async () => {
+          admin = await userFactory(testEnv, peterLustig)
+          await mutate({
+            mutation: login,
+            variables: { email: 'peter@lustig.de', password: 'Aa12345_' },
+          })
+
+          await userFactory(testEnv, bibiBloxberg)
+          await userFactory(testEnv, stephenHawking)
+          await userFactory(testEnv, garrickOllivander)
+        })
+
+        afterAll(async () => {
+          await cleanDB()
+          resetToken()
+        })
+
+        describe('without any filters', () => {
+          it('finds all users', async () => {
+            await expect(
+              query({
+                query: searchUsers,
+                variables: {
+                  ...variablesWithoutTextAndFilters,
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  searchUsers: {
+                    userCount: 4,
+                    userList: expect.arrayContaining(objectValuesToArray(allUsers)),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('all filters are null', () => {
+          it('finds all users', async () => {
+            await expect(
+              query({
+                query: searchUsers,
+                variables: {
+                  ...variablesWithoutTextAndFilters,
+                  filters: {
+                    byActivated: null,
+                    byDeleted: null,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  searchUsers: {
+                    userCount: 4,
+                    userList: expect.arrayContaining(objectValuesToArray(allUsers)),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('filter by unchecked email', () => {
+          it('finds only users with unchecked email', async () => {
+            await expect(
+              query({
+                query: searchUsers,
+                variables: {
+                  ...variablesWithoutTextAndFilters,
+                  filters: {
+                    byActivated: false,
+                    byDeleted: null,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  searchUsers: {
+                    userCount: 1,
+                    userList: expect.arrayContaining([allUsers.garrick]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('filter by deleted users', () => {
+          it('finds only users with deleted account', async () => {
+            await expect(
+              query({
+                query: searchUsers,
+                variables: {
+                  ...variablesWithoutTextAndFilters,
+                  filters: {
+                    byActivated: null,
+                    byDeleted: true,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  searchUsers: {
+                    userCount: 1,
+                    userList: expect.arrayContaining([allUsers.stephen]),
+                  },
+                },
+              }),
+            )
+          })
+        })
+
+        describe('filter by deleted account and unchecked email', () => {
+          it('finds no users', async () => {
+            await expect(
+              query({
+                query: searchUsers,
+                variables: {
+                  ...variablesWithoutTextAndFilters,
+                  filters: {
+                    byActivated: false,
+                    byDeleted: true,
+                  },
+                },
+              }),
+            ).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  searchUsers: {
+                    userCount: 0,
+                    userList: [],
+                  },
+                },
+              }),
+            )
+          })
+        })
+      })
+    })
+  })
 })
 
 describe('printTimeDuration', () => {

backend/src/graphql/resolver/UserResolver.ts

@@ -1,25 +1,51 @@
 import fs from 'fs'
-import { backendLogger as logger } from '@/server/logger'
 import i18n from 'i18n'
-import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
-import { Resolver, Query, Args, Arg, Authorized, Ctx, UseMiddleware, Mutation } from 'type-graphql'
+import { v4 as uuidv4 } from 'uuid'
+import {
+  Resolver,
+  Query,
+  Args,
+  Arg,
+  Authorized,
+  Ctx,
+  UseMiddleware,
+  Mutation,
+  Int,
+} from 'type-graphql'
 import { getConnection, getCustomRepository, IsNull, Not } from '@dbTools/typeorm'
-import CONFIG from '@/config'
-import { User } from '@model/User'
+
 import { User as DbUser } from '@entity/User'
 import { UserContact as DbUserContact } from '@entity/UserContact'
-import { communityDbUser } from '@/util/communityUser'
-import { TransactionLink as dbTransactionLink } from '@entity/TransactionLink'
-import { ContributionLink as dbContributionLink } from '@entity/ContributionLink'
-import { encode } from '@/auth/JWT'
+import { TransactionLink as DbTransactionLink } from '@entity/TransactionLink'
+import { ContributionLink as DbContributionLink } from '@entity/ContributionLink'
+import { UserRepository } from '@repository/User'
+
+import { User } from '@model/User'
+import { SearchAdminUsersResult } from '@model/AdminUser'
+import { UserAdmin, SearchUsersResult } from '@model/UserAdmin'
+import { OptInType } from '@enum/OptInType'
+import { Order } from '@enum/Order'
+import { UserContactType } from '@enum/UserContactType'
+
+import {
+  sendAccountActivationEmail,
+  sendAccountMultiRegistrationEmail,
+  sendResetPasswordEmail,
+} from '@/emails/sendEmailVariants'
+
+import { getTimeDurationObject, printTimeDuration } from '@/util/time'
 import CreateUserArgs from '@arg/CreateUserArgs'
 import UnsecureLoginArgs from '@arg/UnsecureLoginArgs'
 import UpdateUserInfosArgs from '@arg/UpdateUserInfosArgs'
+import Paginated from '@arg/Paginated'
+import SearchUsersArgs from '@arg/SearchUsersArgs'
+
+import { backendLogger as logger } from '@/server/logger'
+import { Context, getUser, getClientTimezoneOffset } from '@/server/context'
+import CONFIG from '@/config'
+import { communityDbUser } from '@/util/communityUser'
+import { encode } from '@/auth/JWT'
 import { klicktippNewsletterStateMiddleware } from '@/middleware/klicktippMiddleware'
-import { OptInType } from '@enum/OptInType'
-import { sendResetPasswordEmail as sendResetPasswordEmailMailer } from '@/mailer/sendResetPasswordEmail'
-import { sendAccountActivationEmail } from '@/mailer/sendAccountActivationEmail'
-import { sendAccountMultiRegistrationEmail } from '@/emails/sendEmailVariants'
 import { klicktippSignIn } from '@/apis/KlicktippController'
 import { RIGHTS } from '@/auth/RIGHTS'
 import { hasElopageBuys } from '@/util/hasElopageBuys'
@@ -33,13 +59,8 @@ import {
   EventSendConfirmationEmail,
   EventActivateAccount,
 } from '@/event/Event'
-import { getUserCreation } from './util/creations'
-import { UserContactType } from '../enum/UserContactType'
-import { UserRepository } from '@/typeorm/repository/User'
-import { SearchAdminUsersResult } from '@model/AdminUser'
-import Paginated from '@arg/Paginated'
-import { Order } from '@enum/Order'
-import { v4 as uuidv4 } from 'uuid'
+import { getUserCreation, getUserCreations } from './util/creations'
+import { FULL_CREATION_AVAILABLE } from './const/const'
 import { isValidPassword, SecretKeyCryptographyCreateKey } from '@/password/EncryptorUtils'
 import { encryptPassword, verifyPassword } from '@/password/PasswordEncryptor'
 import { PasswordEncryptionType } from '../enum/PasswordEncryptionType'
@@ -105,16 +126,6 @@ const KeyPairEd25519Create = (passphrase: string[]): Buffer[] => {
   return [pubKey, privKey]
 }
 
-/*
-const getEmailHash = (email: string): Buffer => {
-  logger.trace('getEmailHash...')
-  const emailHash = Buffer.alloc(sodium.crypto_generichash_BYTES)
-  sodium.crypto_generichash(emailHash, Buffer.from(email))
-  logger.debug(`getEmailHash...successful: ${emailHash}`)
-  return emailHash
-}
-*/
-
 const SecretKeyCryptographyEncrypt = (message: Buffer, encryptionKey: Buffer): Buffer => {
   logger.trace('SecretKeyCryptographyEncrypt...')
   const encrypted = Buffer.alloc(message.length + sodium.crypto_secretbox_MACBYTES)
@@ -150,91 +161,6 @@ const newEmailContact = (email: string, userId: number): DbUserContact => {
   logger.debug(`newEmailContact...successful: ${emailContact}`)
   return emailContact
 }
-/*
-const newEmailOptIn = (userId: number): LoginEmailOptIn => {
-  logger.trace('newEmailOptIn...')
-  const emailOptIn = new LoginEmailOptIn()
-  emailOptIn.verificationCode = random(64)
-  emailOptIn.userId = userId
-  emailOptIn.emailOptInTypeId = OptInType.EMAIL_OPT_IN_REGISTER
-  logger.debug(`newEmailOptIn...successful: ${emailOptIn}`)
-  return emailOptIn
-}
-*/
-/*
-// needed by AdminResolver
-// checks if given code exists and can be resent
-// if optIn does not exits, it is created
-export const checkOptInCode = async (
-  optInCode: LoginEmailOptIn | undefined,
-  user: DbUser,
-  optInType: OptInType = OptInType.EMAIL_OPT_IN_REGISTER,
-): Promise<LoginEmailOptIn> => {
-  logger.info(`checkOptInCode... ${optInCode}`)
-  if (optInCode) {
-    if (!canResendOptIn(optInCode)) {
-      logger.error(
-        `email already sent less than ${printTimeDuration(
-          CONFIG.EMAIL_CODE_REQUEST_TIME,
-        )} minutes ago`,
-      )
-      throw new Error(
-        `email already sent less than ${printTimeDuration(
-          CONFIG.EMAIL_CODE_REQUEST_TIME,
-        )} minutes ago`,
-      )
-    }
-    optInCode.updatedAt = new Date()
-    optInCode.resendCount++
-  } else {
-    logger.trace('create new OptIn for userId=' + user.id)
-    optInCode = newEmailOptIn(user.id)
-  }
-
-  if (user.emailChecked) {
-    optInCode.emailOptInTypeId = optInType
-  }
-  await LoginEmailOptIn.save(optInCode).catch(() => {
-    logger.error('Unable to save optin code= ' + optInCode)
-    throw new Error('Unable to save optin code.')
-  })
-  logger.debug(`checkOptInCode...successful: ${optInCode} for userid=${user.id}`)
-  return optInCode
-}
-*/
-export const checkEmailVerificationCode = async (
-  emailContact: DbUserContact,
-  optInType: OptInType = OptInType.EMAIL_OPT_IN_REGISTER,
-): Promise<DbUserContact> => {
-  logger.info(`checkEmailVerificationCode... ${emailContact}`)
-  if (emailContact.updatedAt) {
-    if (!canEmailResend(emailContact.updatedAt)) {
-      logger.error(
-        `email already sent less than ${printTimeDuration(
-          CONFIG.EMAIL_CODE_REQUEST_TIME,
-        )} minutes ago`,
-      )
-      throw new Error(
-        `email already sent less than ${printTimeDuration(
-          CONFIG.EMAIL_CODE_REQUEST_TIME,
-        )} minutes ago`,
-      )
-    }
-    emailContact.updatedAt = new Date()
-    emailContact.emailResendCount++
-  } else {
-    logger.trace('create new EmailVerificationCode for userId=' + emailContact.userId)
-    emailContact.emailChecked = false
-    emailContact.emailVerificationCode = random(64)
-  }
-  emailContact.emailOptInTypeId = optInType
-  await DbUserContact.save(emailContact).catch(() => {
-    logger.error('Unable to save email verification code= ' + emailContact)
-    throw new Error('Unable to save email verification code.')
-  })
-  logger.debug(`checkEmailVerificationCode...successful: ${emailContact}`)
-  return emailContact
-}
 
 export const activationLink = (verificationCode: BigInt): string => {
   logger.debug(`activationLink(${verificationCode})...`)
@@ -345,6 +271,7 @@ export class UserResolver {
   @Authorized([RIGHTS.LOGOUT])
   @Mutation(() => String)
   async logout(): Promise<boolean> {
+    // TODO: Event still missing here!!
     // TODO: We dont need this anymore, but might need this in the future in oder to invalidate a valid JWT-Token.
     // Furthermore this hook can be useful for tracking user behaviour (did he logout or not? Warn him if he didn't on next login)
     // The functionality is fully client side - the client just needs to delete his token with the current implementation.
@@ -447,7 +374,7 @@ export class UserResolver {
     logger.debug('new dbUser=' + dbUser)
     if (redeemCode) {
       if (redeemCode.match(/^CL-/)) {
-        const contributionLink = await dbContributionLink.findOne({
+        const contributionLink = await DbContributionLink.findOne({
           code: redeemCode.replace('CL-', ''),
         })
         logger.info('redeemCode found contributionLink=' + contributionLink)
@@ -456,7 +383,7 @@ export class UserResolver {
           eventRedeemRegister.contributionId = contributionLink.id
         }
       } else {
-        const transactionLink = await dbTransactionLink.findOne({ code: redeemCode })
+        const transactionLink = await DbTransactionLink.findOne({ code: redeemCode })
         logger.info('redeemCode found transactionLink=' + transactionLink)
         if (transactionLink) {
           dbUser.referrerId = transactionLink.userId
@@ -507,11 +434,12 @@ export class UserResolver {
 
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const emailSent = await sendAccountActivationEmail({
-        link: activationLink,
         firstName,
         lastName,
         email,
-        duration: printTimeDuration(CONFIG.EMAIL_CODE_VALID_TIME),
+        language,
+        activationLink,
+        timeDurationObject: getTimeDurationObject(CONFIG.EMAIL_CODE_VALID_TIME),
       })
       logger.info(`sendAccountActivationEmail of ${firstName}.${lastName} to ${email}`)
       eventSendConfirmEmail.userId = dbUser.id
@@ -557,31 +485,45 @@ export class UserResolver {
       return true
     }
 
-    // can be both types: REGISTER and RESET_PASSWORD
-    // let optInCode = await LoginEmailOptIn.findOne({
-    //  userId: user.id,
-    // })
-    // let optInCode = user.emailContact.emailVerificationCode
-    const dbUserContact = await checkEmailVerificationCode(
-      user.emailContact,
-      OptInType.EMAIL_OPT_IN_RESET_PASSWORD,
-    )
+    if (!canEmailResend(user.emailContact.updatedAt || user.emailContact.createdAt)) {
+      logger.error(
+        `email already sent less than ${printTimeDuration(
+          CONFIG.EMAIL_CODE_REQUEST_TIME,
+        )} minutes ago`,
+      )
+      throw new Error(
+        `email already sent less than ${printTimeDuration(
+          CONFIG.EMAIL_CODE_REQUEST_TIME,
+        )} minutes ago`,
+      )
+    }
 
-    // optInCode = await checkOptInCode(optInCode, user, OptInType.EMAIL_OPT_IN_RESET_PASSWORD)
-    logger.info(`optInCode for ${email}=${dbUserContact}`)
+    user.emailContact.updatedAt = new Date()
+    user.emailContact.emailResendCount++
+    user.emailContact.emailVerificationCode = random(64)
+    user.emailContact.emailOptInTypeId = OptInType.EMAIL_OPT_IN_RESET_PASSWORD
+    await user.emailContact.save().catch(() => {
+      logger.error('Unable to save email verification code= ' + user.emailContact)
+      throw new Error('Unable to save email verification code.')
+    })
+
+    logger.info(`optInCode for ${email}=${user.emailContact}`)
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const emailSent = await sendResetPasswordEmailMailer({
-      link: activationLink(dbUserContact.emailVerificationCode),
+    const emailSent = await sendResetPasswordEmail({
       firstName: user.firstName,
       lastName: user.lastName,
       email,
-      duration: printTimeDuration(CONFIG.EMAIL_CODE_VALID_TIME),
+      language: user.language,
+      resetLink: activationLink(user.emailContact.emailVerificationCode),
+      timeDurationObject: getTimeDurationObject(CONFIG.EMAIL_CODE_VALID_TIME),
     })
 
     /*  uncomment this, when you need the activation link on the console */
     // In case EMails are disabled log the activation link for the user
     if (!emailSent) {
-      logger.debug(`Reset password link: ${activationLink(dbUserContact.emailVerificationCode)}`)
+      logger.debug(
+        `Reset password link: ${activationLink(user.emailContact.emailVerificationCode)}`,
+      )
     }
     logger.info(`forgotPassword(${email}) successful...`)
 
@@ -619,7 +561,7 @@ export class UserResolver {
     })
     logger.debug('userContact loaded...')
     // Code is only valid for `CONFIG.EMAIL_CODE_VALID_TIME` minutes
-    if (!isEmailVerificationCodeValid(userContact.updatedAt)) {
+    if (!isEmailVerificationCodeValid(userContact.updatedAt || userContact.createdAt)) {
       logger.error(
         `email was sent more than ${printTimeDuration(CONFIG.EMAIL_CODE_VALID_TIME)} ago`,
       )
@@ -723,7 +665,7 @@ export class UserResolver {
     const userContact = await DbUserContact.findOneOrFail({ emailVerificationCode: optIn })
     logger.debug(`found optInCode=${userContact}`)
     // Code is only valid for `CONFIG.EMAIL_CODE_VALID_TIME` minutes
-    if (!isEmailVerificationCodeValid(userContact.updatedAt)) {
+    if (!isEmailVerificationCodeValid(userContact.updatedAt || userContact.createdAt)) {
       logger.error(
         `email was sent more than ${printTimeDuration(CONFIG.EMAIL_CODE_VALID_TIME)} ago`,
       )
@@ -859,6 +801,206 @@ export class UserResolver {
       }),
     }
   }
+
+  @Authorized([RIGHTS.SEARCH_USERS])
+  @Query(() => SearchUsersResult)
+  async searchUsers(
+    @Args()
+    { searchText, currentPage = 1, pageSize = 25, filters }: SearchUsersArgs,
+    @Ctx() context: Context,
+  ): Promise<SearchUsersResult> {
+    const clientTimezoneOffset = getClientTimezoneOffset(context)
+    const userRepository = getCustomRepository(UserRepository)
+    const userFields = [
+      'id',
+      'firstName',
+      'lastName',
+      'emailId',
+      'emailContact',
+      'deletedAt',
+      'isAdmin',
+    ]
+    const [users, count] = await userRepository.findBySearchCriteriaPagedFiltered(
+      userFields.map((fieldName) => {
+        return 'user.' + fieldName
+      }),
+      searchText,
+      filters,
+      currentPage,
+      pageSize,
+    )
+
+    if (users.length === 0) {
+      return {
+        userCount: 0,
+        userList: [],
+      }
+    }
+
+    const creations = await getUserCreations(
+      users.map((u) => u.id),
+      clientTimezoneOffset,
+    )
+
+    const adminUsers = await Promise.all(
+      users.map(async (user) => {
+        let emailConfirmationSend = ''
+        if (!user.emailContact.emailChecked) {
+          if (user.emailContact.updatedAt) {
+            emailConfirmationSend = user.emailContact.updatedAt.toISOString()
+          } else {
+            emailConfirmationSend = user.emailContact.createdAt.toISOString()
+          }
+        }
+        const userCreations = creations.find((c) => c.id === user.id)
+        const adminUser = new UserAdmin(
+          user,
+          userCreations ? userCreations.creations : FULL_CREATION_AVAILABLE,
+          await hasElopageBuys(user.emailContact.email),
+          emailConfirmationSend,
+        )
+        return adminUser
+      }),
+    )
+    return {
+      userCount: count,
+      userList: adminUsers,
+    }
+  }
+
+  @Authorized([RIGHTS.SET_USER_ROLE])
+  @Mutation(() => Date, { nullable: true })
+  async setUserRole(
+    @Arg('userId', () => Int)
+    userId: number,
+    @Arg('isAdmin', () => Boolean)
+    isAdmin: boolean,
+    @Ctx()
+    context: Context,
+  ): Promise<Date | null> {
+    const user = await DbUser.findOne({ id: userId })
+    // user exists ?
+    if (!user) {
+      logger.error(`Could not find user with userId: ${userId}`)
+      throw new Error(`Could not find user with userId: ${userId}`)
+    }
+    // administrator user changes own role?
+    const moderatorUser = getUser(context)
+    if (moderatorUser.id === userId) {
+      logger.error('Administrator can not change his own role!')
+      throw new Error('Administrator can not change his own role!')
+    }
+    // change isAdmin
+    switch (user.isAdmin) {
+      case null:
+        if (isAdmin === true) {
+          user.isAdmin = new Date()
+        } else {
+          logger.error('User is already a usual user!')
+          throw new Error('User is already a usual user!')
+        }
+        break
+      default:
+        if (isAdmin === false) {
+          user.isAdmin = null
+        } else {
+          logger.error('User is already admin!')
+          throw new Error('User is already admin!')
+        }
+        break
+    }
+    await user.save()
+    const newUser = await DbUser.findOne({ id: userId })
+    return newUser ? newUser.isAdmin : null
+  }
+
+  @Authorized([RIGHTS.DELETE_USER])
+  @Mutation(() => Date, { nullable: true })
+  async deleteUser(
+    @Arg('userId', () => Int) userId: number,
+    @Ctx() context: Context,
+  ): Promise<Date | null> {
+    const user = await DbUser.findOne({ id: userId })
+    // user exists ?
+    if (!user) {
+      logger.error(`Could not find user with userId: ${userId}`)
+      throw new Error(`Could not find user with userId: ${userId}`)
+    }
+    // moderator user disabled own account?
+    const moderatorUser = getUser(context)
+    if (moderatorUser.id === userId) {
+      logger.error('Moderator can not delete his own account!')
+      throw new Error('Moderator can not delete his own account!')
+    }
+    // soft-delete user
+    await user.softRemove()
+    const newUser = await DbUser.findOne({ id: userId }, { withDeleted: true })
+    return newUser ? newUser.deletedAt : null
+  }
+
+  @Authorized([RIGHTS.UNDELETE_USER])
+  @Mutation(() => Date, { nullable: true })
+  async unDeleteUser(@Arg('userId', () => Int) userId: number): Promise<Date | null> {
+    const user = await DbUser.findOne({ id: userId }, { withDeleted: true })
+    if (!user) {
+      logger.error(`Could not find user with userId: ${userId}`)
+      throw new Error(`Could not find user with userId: ${userId}`)
+    }
+    if (!user.deletedAt) {
+      logger.error('User is not deleted')
+      throw new Error('User is not deleted')
+    }
+    await user.recover()
+    return null
+  }
+
+  @Authorized([RIGHTS.SEND_ACTIVATION_EMAIL])
+  @Mutation(() => Boolean)
+  async sendActivationEmail(@Arg('email') email: string): Promise<boolean> {
+    email = email.trim().toLowerCase()
+    // const user = await dbUser.findOne({ id: emailContact.userId })
+    const user = await findUserByEmail(email)
+    if (!user) {
+      logger.error(`Could not find User to emailContact: ${email}`)
+      throw new Error(`Could not find User to emailContact: ${email}`)
+    }
+    if (user.deletedAt) {
+      logger.error(`User with emailContact: ${email} is deleted.`)
+      throw new Error(`User with emailContact: ${email} is deleted.`)
+    }
+    const emailContact = user.emailContact
+    if (emailContact.deletedAt) {
+      logger.error(`The emailContact: ${email} of this User is deleted.`)
+      throw new Error(`The emailContact: ${email} of this User is deleted.`)
+    }
+
+    emailContact.emailResendCount++
+    await emailContact.save()
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const emailSent = await sendAccountActivationEmail({
+      firstName: user.firstName,
+      lastName: user.lastName,
+      email,
+      language: user.language,
+      activationLink: activationLink(emailContact.emailVerificationCode),
+      timeDurationObject: getTimeDurationObject(CONFIG.EMAIL_CODE_VALID_TIME),
+    })
+
+    // In case EMails are disabled log the activation link for the user
+    if (!emailSent) {
+      logger.info(`Account confirmation link: ${activationLink}`)
+    } else {
+      const event = new Event()
+      const eventSendConfirmationEmail = new EventSendConfirmationEmail()
+      eventSendConfirmationEmail.userId = user.id
+      await eventProtocol.writeEvent(
+        event.setEventSendConfirmationEmail(eventSendConfirmationEmail),
+      )
+    }
+
+    return true
+  }
 }
 
 export async function findUserByEmail(email: string): Promise<DbUser> {
@@ -899,10 +1041,7 @@ const isOptInValid = (optIn: LoginEmailOptIn): boolean => {
   return isTimeExpired(optIn, CONFIG.EMAIL_CODE_VALID_TIME)
 }
 */
-const isEmailVerificationCodeValid = (updatedAt: Date | null): boolean => {
-  if (updatedAt == null) {
-    return true
-  }
+const isEmailVerificationCodeValid = (updatedAt: Date): boolean => {
   return isTimeExpired(updatedAt, CONFIG.EMAIL_CODE_VALID_TIME)
 }
 /*
@@ -913,20 +1052,3 @@ const canResendOptIn = (optIn: LoginEmailOptIn): boolean => {
 const canEmailResend = (updatedAt: Date): boolean => {
   return !isTimeExpired(updatedAt, CONFIG.EMAIL_CODE_REQUEST_TIME)
 }
-
-const getTimeDurationObject = (time: number): { hours?: number; minutes: number } => {
-  if (time > 60) {
-    return {
-      hours: Math.floor(time / 60),
-      minutes: time % 60,
-    }
-  }
-  return { minutes: time }
-}
-
-export const printTimeDuration = (duration: number): string => {
-  const time = getTimeDurationObject(duration)
-  const result = time.minutes > 0 ? `${time.minutes} minutes` : ''
-  if (time.hours) return `${time.hours} hours` + (result !== '' ? ` and ${result}` : '')
-  return result
-}

backend/src/graphql/resolver/util/creations.ts

@@ -103,6 +103,9 @@ export const getUserCreation = async (
 const getCreationMonths = (timezoneOffset: number): number[] => {
   const clientNow = new Date()
   clientNow.setTime(clientNow.getTime() - timezoneOffset * 60 * 1000)
+  logger.info(
+    `getCreationMonths -- offset: ${timezoneOffset} -- clientNow: ${clientNow.toISOString()}`,
+  )
   return [
     new Date(clientNow.getFullYear(), clientNow.getMonth() - 2, 1).getMonth() + 1,
     new Date(clientNow.getFullYear(), clientNow.getMonth() - 1, 1).getMonth() + 1,

backend/src/graphql/union/QueryLinkResult.ts

@@ -0,0 +1,7 @@
+import { createUnionType } from 'type-graphql'
+import { TransactionLink } from '@model/TransactionLink'
+import { ContributionLink } from '@model/ContributionLink'
+export default createUnionType({
+  name: 'QueryLinkResult', // the name of the GraphQL union
+  types: () => [TransactionLink, ContributionLink] as const, // function that returns tuple of object types classes
+})

backend/src/locales/de.json

@@ -1,15 +1,61 @@
 {
   "emails": {
+    "addedContributionMessage": {
+      "commonGoodContributionMessage": "du hast zu deinem Gemeinwohl-Beitrag „{contributionMemo}“ eine Nachricht von {senderFirstName} {senderLastName} erhalten.",
+      "subject": "Gradido: Nachricht zu deinem Gemeinwohl-Beitrag",
+      "toSeeAndAnswerMessage": "Um die Nachricht zu sehen und darauf zu antworten, gehe in deinem Gradido-Konto ins Menü „Gemeinschaft“ auf den Tab „Meine Beiträge zum Gemeinwohl“!"
+    },
+    "accountActivation": {
+      "duration": "Der Link hat eine Gültigkeit von {hours} Stunden und {minutes} Minuten. Sollte die Gültigkeit des Links bereits abgelaufen sein, kannst du dir hier einen neuen Link schicken lassen, in dem du deine E-Mail-Adresse eingibst:",
+      "emailRegistered": "deine E-Mail-Adresse wurde soeben bei Gradido registriert.",
+      "pleaseClickLink": "Klicke bitte auf diesen Link, um die Registrierung abzuschließen und dein Gradido-Konto zu aktivieren:",
+      "subject": "Gradido: E-Mail Überprüfung"
+    },
     "accountMultiRegistration": {
       "emailExists": "Es existiert jedoch zu deiner E-Mail-Adresse schon ein Konto.",
-      "emailReused": "Deine E-Mail-Adresse wurde soeben erneut benutzt, um bei Gradido ein Konto zu registrieren.",
-      "helloName": "Hallo {firstName} {lastName}",
+      "emailReused": "deine E-Mail-Adresse wurde soeben erneut benutzt, um bei Gradido ein Konto zu registrieren.",
       "ifYouAreNotTheOne": "Wenn du nicht derjenige bist, der sich versucht hat erneut zu registrieren, wende dich bitte an unseren support:",
       "onForgottenPasswordClickLink": "Klicke bitte auf den folgenden Link, falls du dein Passwort vergessen haben solltest:",
       "onForgottenPasswordCopyLink": "oder kopiere den obigen Link in dein Browserfenster.",
-      "sincerelyYours": "Mit freundlichen Grüßen,",
-      "subject": "Gradido: Erneuter Registrierungsversuch mit deiner E-Mail",
+      "subject": "Gradido: Erneuter Registrierungsversuch mit deiner E-Mail"
+    },
+    "contributionConfirmed": {
+      "commonGoodContributionConfirmed": "dein Gemeinwohl-Beitrag „{contributionMemo}“ wurde soeben von {senderFirstName} {senderLastName} bestätigt und in deinem Gradido-Konto gutgeschrieben.",
+      "subject": "Gradido: Dein Gemeinwohl-Beitrag wurde bestätigt"
+    },
+    "contributionRejected": {
+      "commonGoodContributionRejected": "dein Gemeinwohl-Beitrag „{contributionMemo}“ wurde von {senderFirstName} {senderLastName} abgelehnt.",
+      "subject": "Gradido: Dein Gemeinwohl-Beitrag wurde abgelehnt",
+      "toSeeContributionsAndMessages": "Um deine Gemeinwohl-Beiträge und dazugehörige Nachrichten zu sehen, gehe in deinem Gradido-Konto ins Menü „Gemeinschaft“ auf den Tab „Meine Beiträge zum Gemeinwohl“!"
+    },
+    "general": {
+      "amountGDD": "Betrag: {amountGDD} GDD",
+      "detailsYouFindOnLinkToYourAccount": "Details zur Transaktion findest du in deinem Gradido-Konto:",
+      "doNotAnswer": "nicht antworten",
+      "helloName": "Hallo {firstName} {lastName},",
+      "linkToYourAccount": "Link zu deinem Konto:",
+      "orCopyLink": "oder kopiere den obigen Link in dein Browserfenster.",
+      "pleaseDoNotReply": "Bitte antworte nicht auf diese E-Mail!",
+      "sincerelyYours": "Liebe Grüße",
       "yourGradidoTeam": "dein Gradido-Team"
+    },
+    "resetPassword": {
+      "duration": "Der Link hat eine Gültigkeit von {hours} Stunden und {minutes} Minuten. Sollte die Gültigkeit des Links bereits abgelaufen sein, kannst du dir hier einen neuen Link schicken lassen, in dem du deine E-Mail-Adresse eingibst:",
+      "pleaseClickLink": "Wenn du es warst, klicke bitte auf den Link:",
+      "subject": "Gradido: Passwort zurücksetzen",
+      "youOrSomeoneResetPassword": "du, oder jemand anderes, hast für dieses Konto ein Zurücksetzen des Passworts angefordert."
+    },
+    "transactionLinkRedeemed": {
+      "hasRedeemedYourLink": "{senderFirstName} {senderLastName} ({senderEmail}) hat soeben deinen Link eingelöst.",
+      "memo": "Memo: {transactionMemo}",
+      "subject": "Gradido: Dein Gradido-Link wurde eingelöst"
+    },
+    "transactionReceived": {
+      "haveReceivedAmountGDDFrom": "du hast soeben {transactionAmount} GDD von {senderFirstName} {senderLastName} ({senderEmail}) erhalten.",
+      "subject": "Gradido: Du hast Gradidos erhalten"
     }
+  },
+  "general": {
+    "decimalSeparator": ","
   }
-}
+}

backend/src/locales/en.json

@@ -1,15 +1,61 @@
 {
-	"emails": {
-		"accountMultiRegistration": {
+  "emails": {
+    "addedContributionMessage": {
+      "commonGoodContributionMessage": "you have received a message from {senderFirstName} {senderLastName} regarding your common good contribution “{contributionMemo}”.",
+      "subject": "Gradido: Message about your common good contribution",
+      "toSeeAndAnswerMessage": "To view and reply to the message, go to the “Community” menu in your Gradido account and click on the “My contributions to the common good” tab!"
+    },
+    "accountActivation": {
+      "duration": "The link has a validity of {hours} hours and {minutes} minutes. If the validity of the link has already expired, you can have a new link sent to you here by entering your email address:",
+      "emailRegistered": "Your email address has just been registered with Gradido.",
+      "pleaseClickLink": "Please click on this link to complete the registration and activate your Gradido account:",
+      "subject": "Gradido: Email Verification"
+    },
+    "accountMultiRegistration": {
       "emailExists": "However, an account already exists for your email address.",
       "emailReused": "Your email address has just been used again to register an account with Gradido.",
-			"helloName": "Hello {firstName} {lastName}",
       "ifYouAreNotTheOne": "If you are not the one who tried to register again, please contact our support:",
       "onForgottenPasswordClickLink": "Please click on the following link if you have forgotten your password:",
       "onForgottenPasswordCopyLink": "or copy the link above into your browser window.",
-      "sincerelyYours": "Sincerely yours,",
-			"subject": "Gradido: Try To Register Again With Your Email",
+      "subject": "Gradido: Try To Register Again With Your Email"
+    },
+    "contributionConfirmed": {
+      "commonGoodContributionConfirmed": "Your public good contribution “{contributionMemo}” has just been confirmed by {senderFirstName} {senderLastName} and credited to your Gradido account.",
+      "subject": "Gradido: Your common good contribution was confirmed"
+    },
+    "contributionRejected": {
+      "commonGoodContributionRejected": "Your public good contribution “{contributionMemo}” was rejected by {senderFirstName} {senderLastName}.",
+      "subject": "Gradido: Your common good contribution was rejected",
+      "toSeeContributionsAndMessages": "To see your common good contributions and related messages, go to the “Community” menu in your Gradido account and click on the “My contributions to the common good” tab!"
+    },
+    "general": {
+      "amountGDD": "Amount: {amountGDD} GDD",
+      "detailsYouFindOnLinkToYourAccount": "You can find transaction details in your Gradido account:",
+      "doNotAnswer": "do not answer",
+      "helloName": "Hello {firstName} {lastName}",
+      "linkToYourAccount": "Link to your account:",
+      "orCopyLink": "or copy the link above into your browser window.",
+      "pleaseDoNotReply": "Please do not reply to this email!",
+      "sincerelyYours": "Kind regards,",
       "yourGradidoTeam": "your Gradido team"
-		}
-	}
-}
+    },
+    "resetPassword": {
+      "duration": "The link has a validity of {hours} hours and {minutes} minutes. If the validity of the link has already expired, you can have a new link sent to you here by entering your email address:",
+      "pleaseClickLink": "If it was you, please click on the link:",
+      "subject": "Gradido: Reset password",
+      "youOrSomeoneResetPassword": "You, or someone else, requested a password reset for this account."
+    },
+    "transactionLinkRedeemed": {
+      "hasRedeemedYourLink": "{senderFirstName} {senderLastName} ({senderEmail}) has just redeemed your link.",
+      "memo": "Memo: {transactionMemo}",
+      "subject": "Gradido: Your Gradido link has been redeemed"
+    },
+    "transactionReceived": {
+      "haveReceivedAmountGDDFrom": "You have just received {transactionAmount} GDD from {senderFirstName} {senderLastName} ({senderEmail}).",
+      "subject": "Gradido: You have received Gradidos"
+    }
+  },
+  "general": {
+    "decimalSeparator": "."
+  }
+}

backend/src/mailer/sendAccountActivationEmail.test.ts

@@ -1,32 +0,0 @@
-import { sendAccountActivationEmail } from './sendAccountActivationEmail'
-import { sendEMail } from './sendEMail'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendAccountActivationEmail', () => {
-  beforeEach(async () => {
-    await sendAccountActivationEmail({
-      link: 'activationLink',
-      firstName: 'Peter',
-      lastName: 'Lustig',
-      email: 'peter@lustig.de',
-      duration: '23 hours and 30 minutes',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: `Peter Lustig <peter@lustig.de>`,
-      subject: 'Gradido: E-Mail Überprüfung',
-      text:
-        expect.stringContaining('Hallo Peter Lustig') &&
-        expect.stringContaining('activationLink') &&
-        expect.stringContaining('23 Stunden und 30 Minuten'),
-    })
-  })
-})

backend/src/mailer/sendAccountActivationEmail.ts

@@ -1,17 +0,0 @@
-import { sendEMail } from './sendEMail'
-import { accountActivation } from './text/accountActivation'
-import CONFIG from '@/config'
-
-export const sendAccountActivationEmail = (data: {
-  link: string
-  firstName: string
-  lastName: string
-  email: string
-  duration: string
-}): Promise<boolean> => {
-  return sendEMail({
-    to: `${data.firstName} ${data.lastName} <${data.email}>`,
-    subject: accountActivation.de.subject,
-    text: accountActivation.de.text({ ...data, resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD }),
-  })
-}

backend/src/mailer/sendAddedContributionMessageEmail.test.ts

@@ -1,40 +0,0 @@
-import { sendAddedContributionMessageEmail } from './sendAddedContributionMessageEmail'
-import { sendEMail } from './sendEMail'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendAddedContributionMessageEmail', () => {
-  beforeEach(async () => {
-    await sendAddedContributionMessageEmail({
-      senderFirstName: 'Peter',
-      senderLastName: 'Lustig',
-      recipientFirstName: 'Bibi',
-      recipientLastName: 'Bloxberg',
-      recipientEmail: 'bibi@bloxberg.de',
-      senderEmail: 'peter@lustig.de',
-      contributionMemo: 'Vielen herzlichen Dank für den neuen Hexenbesen!',
-      message: 'Was für ein Besen ist es geworden?',
-      overviewURL: 'http://localhost/overview',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: `Bibi Bloxberg <bibi@bloxberg.de>`,
-      subject: 'Nachricht zu deinem Gemeinwohl-Beitrag',
-      text:
-        expect.stringContaining('Hallo Bibi Bloxberg') &&
-        expect.stringContaining('Peter Lustig') &&
-        expect.stringContaining(
-          'du hast zu deinem Gemeinwohl-Beitrag "Vielen herzlichen Dank für den neuen Hexenbesen!" eine Nachricht von Peter Lustig erhalten.',
-        ) &&
-        expect.stringContaining('Was für ein Besen ist es geworden?') &&
-        expect.stringContaining('http://localhost/overview'),
-    })
-  })
-})

backend/src/mailer/sendAddedContributionMessageEmail.ts

@@ -1,26 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import { sendEMail } from './sendEMail'
-import { contributionMessageReceived } from './text/contributionMessageReceived'
-
-export const sendAddedContributionMessageEmail = (data: {
-  senderFirstName: string
-  senderLastName: string
-  recipientFirstName: string
-  recipientLastName: string
-  recipientEmail: string
-  senderEmail: string
-  contributionMemo: string
-  message: string
-  overviewURL: string
-}): Promise<boolean> => {
-  logger.info(
-    `sendEmail(): to=${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>,
-      subject=${contributionMessageReceived.de.subject},
-      text=${contributionMessageReceived.de.text(data)}`,
-  )
-  return sendEMail({
-    to: `${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>`,
-    subject: contributionMessageReceived.de.subject,
-    text: contributionMessageReceived.de.text(data),
-  })
-}

backend/src/mailer/sendContributionConfirmedEmail.test.ts

@@ -1,39 +0,0 @@
-import Decimal from 'decimal.js-light'
-import { sendContributionConfirmedEmail } from './sendContributionConfirmedEmail'
-import { sendEMail } from './sendEMail'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendContributionConfirmedEmail', () => {
-  beforeEach(async () => {
-    await sendContributionConfirmedEmail({
-      senderFirstName: 'Peter',
-      senderLastName: 'Lustig',
-      recipientFirstName: 'Bibi',
-      recipientLastName: 'Bloxberg',
-      recipientEmail: 'bibi@bloxberg.de',
-      contributionMemo: 'Vielen herzlichen Dank für den neuen Hexenbesen!',
-      contributionAmount: new Decimal(200.0),
-      overviewURL: 'http://localhost/overview',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: 'Bibi Bloxberg <bibi@bloxberg.de>',
-      subject: 'Dein Gemeinwohl-Beitrag wurde bestätigt',
-      text:
-        expect.stringContaining('Hallo Bibi Bloxberg') &&
-        expect.stringContaining(
-          'dein Gemeinwohl-Beitrag "Vielen herzlichen Dank für den neuen Hexenbesen!" wurde soeben von Peter Lustig bestätigt und in deinem Gradido-Konto gutgeschrieben.',
-        ) &&
-        expect.stringContaining('Betrag: 200,00 GDD') &&
-        expect.stringContaining('Link zu deinem Konto: http://localhost/overview'),
-    })
-  })
-})

backend/src/mailer/sendContributionConfirmedEmail.ts

@@ -1,26 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import Decimal from 'decimal.js-light'
-import { sendEMail } from './sendEMail'
-import { contributionConfirmed } from './text/contributionConfirmed'
-
-export const sendContributionConfirmedEmail = (data: {
-  senderFirstName: string
-  senderLastName: string
-  recipientFirstName: string
-  recipientLastName: string
-  recipientEmail: string
-  contributionMemo: string
-  contributionAmount: Decimal
-  overviewURL: string
-}): Promise<boolean> => {
-  logger.info(
-    `sendEmail(): to=${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>,
-    subject=${contributionConfirmed.de.subject},
-    text=${contributionConfirmed.de.text(data)}`,
-  )
-  return sendEMail({
-    to: `${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>`,
-    subject: contributionConfirmed.de.subject,
-    text: contributionConfirmed.de.text(data),
-  })
-}

backend/src/mailer/sendContributionRejectedEmail.test.ts

@@ -1,38 +0,0 @@
-import Decimal from 'decimal.js-light'
-import { sendContributionRejectedEmail } from './sendContributionRejectedEmail'
-import { sendEMail } from './sendEMail'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendContributionConfirmedEmail', () => {
-  beforeEach(async () => {
-    await sendContributionRejectedEmail({
-      senderFirstName: 'Peter',
-      senderLastName: 'Lustig',
-      recipientFirstName: 'Bibi',
-      recipientLastName: 'Bloxberg',
-      recipientEmail: 'bibi@bloxberg.de',
-      contributionMemo: 'Vielen herzlichen Dank für den neuen Hexenbesen!',
-      contributionAmount: new Decimal(200.0),
-      overviewURL: 'http://localhost/overview',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: 'Bibi Bloxberg <bibi@bloxberg.de>',
-      subject: 'Dein Gemeinwohl-Beitrag wurde abgelehnt',
-      text:
-        expect.stringContaining('Hallo Bibi Bloxberg') &&
-        expect.stringContaining(
-          'dein Gemeinwohl-Beitrag "Vielen herzlichen Dank für den neuen Hexenbesen!" wurde von Peter Lustig abgelehnt.',
-        ) &&
-        expect.stringContaining('Link zu deinem Konto: http://localhost/overview'),
-    })
-  })
-})

backend/src/mailer/sendContributionRejectedEmail.ts

@@ -1,26 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import Decimal from 'decimal.js-light'
-import { sendEMail } from './sendEMail'
-import { contributionRejected } from './text/contributionRejected'
-
-export const sendContributionRejectedEmail = (data: {
-  senderFirstName: string
-  senderLastName: string
-  recipientFirstName: string
-  recipientLastName: string
-  recipientEmail: string
-  contributionMemo: string
-  contributionAmount: Decimal
-  overviewURL: string
-}): Promise<boolean> => {
-  logger.info(
-    `sendEmail(): to=${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>,
-    subject=${contributionRejected.de.subject},
-    text=${contributionRejected.de.text(data)}`,
-  )
-  return sendEMail({
-    to: `${data.recipientFirstName} ${data.recipientLastName} <${data.recipientEmail}>`,
-    subject: contributionRejected.de.subject,
-    text: contributionRejected.de.text(data),
-  })
-}

backend/src/mailer/sendEMail.test.ts

@@ -1,113 +0,0 @@
-import { sendEMail } from './sendEMail'
-import { createTransport } from 'nodemailer'
-import CONFIG from '@/config'
-
-import { logger } from '@test/testSetup'
-
-CONFIG.EMAIL = false
-CONFIG.EMAIL_SMTP_URL = 'EMAIL_SMTP_URL'
-CONFIG.EMAIL_SMTP_PORT = '1234'
-CONFIG.EMAIL_USERNAME = 'user'
-CONFIG.EMAIL_PASSWORD = 'pwd'
-
-jest.mock('nodemailer', () => {
-  return {
-    __esModule: true,
-    createTransport: jest.fn(() => {
-      return {
-        sendMail: jest.fn(() => {
-          return {
-            messageId: 'message',
-          }
-        }),
-      }
-    }),
-  }
-})
-
-describe('sendEMail', () => {
-  let result: boolean
-  describe('config email is false', () => {
-    beforeEach(async () => {
-      jest.clearAllMocks()
-      result = await sendEMail({
-        to: 'receiver@mail.org',
-        cc: 'support@gradido.net',
-        subject: 'Subject',
-        text: 'Text text text',
-      })
-    })
-
-    it('logs warning', () => {
-      expect(logger.info).toBeCalledWith('Emails are disabled via config...')
-    })
-
-    it('returns false', () => {
-      expect(result).toBeFalsy()
-    })
-  })
-
-  describe('config email is true', () => {
-    beforeEach(async () => {
-      jest.clearAllMocks()
-      CONFIG.EMAIL = true
-      result = await sendEMail({
-        to: 'receiver@mail.org',
-        cc: 'support@gradido.net',
-        subject: 'Subject',
-        text: 'Text text text',
-      })
-    })
-
-    it('calls the transporter', () => {
-      expect(createTransport).toBeCalledWith({
-        host: 'EMAIL_SMTP_URL',
-        port: 1234,
-        secure: false,
-        requireTLS: true,
-        auth: {
-          user: 'user',
-          pass: 'pwd',
-        },
-      })
-    })
-
-    it('calls sendMail of transporter', () => {
-      expect((createTransport as jest.Mock).mock.results[0].value.sendMail).toBeCalledWith({
-        from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`,
-        to: 'receiver@mail.org',
-        cc: 'support@gradido.net',
-        subject: 'Subject',
-        text: 'Text text text',
-      })
-    })
-
-    it('returns true', () => {
-      expect(result).toBeTruthy()
-    })
-  })
-
-  describe('with email EMAIL_TEST_MODUS true', () => {
-    beforeEach(async () => {
-      jest.clearAllMocks()
-      CONFIG.EMAIL = true
-      CONFIG.EMAIL_TEST_MODUS = true
-      result = await sendEMail({
-        to: 'receiver@mail.org',
-        cc: 'support@gradido.net',
-        subject: 'Subject',
-        text: 'Text text text',
-      })
-    })
-
-    it('calls sendMail of transporter with faked to', () => {
-      expect((createTransport as jest.Mock).mock.results[0].value.sendMail).toBeCalledWith({
-        from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`,
-        to: CONFIG.EMAIL_TEST_RECEIVER,
-        cc: 'support@gradido.net',
-        subject: 'Subject',
-        text: 'Text text text',
-      })
-    })
-  })
-})

backend/src/mailer/sendEMail.ts

@@ -1,48 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import { createTransport } from 'nodemailer'
-
-import CONFIG from '@/config'
-
-export const sendEMail = async (emailDef: {
-  to: string
-  cc?: string
-  subject: string
-  text: string
-}): Promise<boolean> => {
-  logger.info(
-    `send Email: to=${emailDef.to}` +
-      (emailDef.cc ? `, cc=${emailDef.cc}` : '') +
-      `, subject=${emailDef.subject}, text=${emailDef.text}`,
-  )
-
-  if (!CONFIG.EMAIL) {
-    logger.info(`Emails are disabled via config...`)
-    return false
-  }
-  if (CONFIG.EMAIL_TEST_MODUS) {
-    logger.info(
-      `Testmodus=ON: change receiver from ${emailDef.to} to ${CONFIG.EMAIL_TEST_RECEIVER}`,
-    )
-    emailDef.to = CONFIG.EMAIL_TEST_RECEIVER
-  }
-  const transporter = createTransport({
-    host: CONFIG.EMAIL_SMTP_URL,
-    port: Number(CONFIG.EMAIL_SMTP_PORT),
-    secure: false, // true for 465, false for other ports
-    requireTLS: true,
-    auth: {
-      user: CONFIG.EMAIL_USERNAME,
-      pass: CONFIG.EMAIL_PASSWORD,
-    },
-  })
-  const info = await transporter.sendMail({
-    ...emailDef,
-    from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`,
-  })
-  if (!info.messageId) {
-    logger.error('error sending notification email, but transaction succeed')
-    throw new Error('error sending notification email, but transaction succeed')
-  }
-  logger.info('send Email successfully.')
-  return true
-}

backend/src/mailer/sendResetPasswordEmail.test.ts

@@ -1,32 +0,0 @@
-import { sendResetPasswordEmail } from './sendResetPasswordEmail'
-import { sendEMail } from './sendEMail'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendResetPasswordEmail', () => {
-  beforeEach(async () => {
-    await sendResetPasswordEmail({
-      link: 'resetLink',
-      firstName: 'Peter',
-      lastName: 'Lustig',
-      email: 'peter@lustig.de',
-      duration: '23 hours and 30 minutes',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: `Peter Lustig <peter@lustig.de>`,
-      subject: 'Gradido: Passwort zurücksetzen',
-      text:
-        expect.stringContaining('Hallo Peter Lustig') &&
-        expect.stringContaining('resetLink') &&
-        expect.stringContaining('23 Stunden und 30 Minuten'),
-    })
-  })
-})

backend/src/mailer/sendResetPasswordEmail.ts

@@ -1,17 +0,0 @@
-import { sendEMail } from './sendEMail'
-import { resetPassword } from './text/resetPassword'
-import CONFIG from '@/config'
-
-export const sendResetPasswordEmail = (data: {
-  link: string
-  firstName: string
-  lastName: string
-  email: string
-  duration: string
-}): Promise<boolean> => {
-  return sendEMail({
-    to: `${data.firstName} ${data.lastName} <${data.email}>`,
-    subject: resetPassword.de.subject,
-    text: resetPassword.de.text({ ...data, resendLink: CONFIG.EMAIL_LINK_FORGOTPASSWORD }),
-  })
-}

backend/src/mailer/sendTransactionLinkRedeemed.test.ts

@@ -1,44 +0,0 @@
-import { sendEMail } from './sendEMail'
-import Decimal from 'decimal.js-light'
-import { sendTransactionLinkRedeemedEmail } from './sendTransactionLinkRedeemed'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendTransactionLinkRedeemedEmail', () => {
-  beforeEach(async () => {
-    await sendTransactionLinkRedeemedEmail({
-      email: 'bibi@bloxberg.de',
-      senderFirstName: 'Peter',
-      senderLastName: 'Lustig',
-      recipientFirstName: 'Bibi',
-      recipientLastName: 'Bloxberg',
-      senderEmail: 'peter@lustig.de',
-      amount: new Decimal(42.0),
-      memo: 'Vielen Dank dass Du dabei bist',
-      overviewURL: 'http://localhost/overview',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: `Bibi Bloxberg <bibi@bloxberg.de>`,
-      subject: 'Gradido-Link wurde eingelöst',
-      text:
-        expect.stringContaining('Hallo Bibi Bloxberg') &&
-        expect.stringContaining(
-          'Peter Lustig (peter@lustig.de) hat soeben deinen Link eingelöst.',
-        ) &&
-        expect.stringContaining('Betrag: 42,00 GDD,') &&
-        expect.stringContaining('Memo: Vielen Dank dass Du dabei bist') &&
-        expect.stringContaining(
-          'Details zur Transaktion findest du in deinem Gradido-Konto: http://localhost/overview',
-        ) &&
-        expect.stringContaining('Bitte antworte nicht auf diese E-Mail!'),
-    })
-  })
-})

backend/src/mailer/sendTransactionLinkRedeemed.ts

@@ -1,28 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import Decimal from 'decimal.js-light'
-import { sendEMail } from './sendEMail'
-import { transactionLinkRedeemed } from './text/transactionLinkRedeemed'
-
-export const sendTransactionLinkRedeemedEmail = (data: {
-  email: string
-  senderFirstName: string
-  senderLastName: string
-  recipientFirstName: string
-  recipientLastName: string
-  senderEmail: string
-  amount: Decimal
-  memo: string
-  overviewURL: string
-}): Promise<boolean> => {
-  logger.info(
-    `sendEmail(): to=${data.recipientFirstName} ${data.recipientLastName},
-        <${data.email}>,
-        subject=${transactionLinkRedeemed.de.subject},
-        text=${transactionLinkRedeemed.de.text(data)}`,
-  )
-  return sendEMail({
-    to: `${data.recipientFirstName} ${data.recipientLastName} <${data.email}>`,
-    subject: transactionLinkRedeemed.de.subject,
-    text: transactionLinkRedeemed.de.text(data),
-  })
-}

backend/src/mailer/sendTransactionReceivedEmail.test.ts

@@ -1,38 +0,0 @@
-import { sendTransactionReceivedEmail } from './sendTransactionReceivedEmail'
-import { sendEMail } from './sendEMail'
-import Decimal from 'decimal.js-light'
-
-jest.mock('./sendEMail', () => {
-  return {
-    __esModule: true,
-    sendEMail: jest.fn(),
-  }
-})
-
-describe('sendTransactionReceivedEmail', () => {
-  beforeEach(async () => {
-    await sendTransactionReceivedEmail({
-      senderFirstName: 'Bibi',
-      senderLastName: 'Bloxberg',
-      recipientFirstName: 'Peter',
-      recipientLastName: 'Lustig',
-      email: 'peter@lustig.de',
-      senderEmail: 'bibi@bloxberg.de',
-      amount: new Decimal(42.0),
-      overviewURL: 'http://localhost/overview',
-    })
-  })
-
-  it('calls sendEMail', () => {
-    expect(sendEMail).toBeCalledWith({
-      to: `Peter Lustig <peter@lustig.de>`,
-      subject: 'Du hast Gradidos erhalten',
-      text:
-        expect.stringContaining('Hallo Peter Lustig') &&
-        expect.stringContaining('42,00 GDD') &&
-        expect.stringContaining('Bibi Bloxberg') &&
-        expect.stringContaining('(bibi@bloxberg.de)') &&
-        expect.stringContaining('http://localhost/overview'),
-    })
-  })
-})

backend/src/mailer/sendTransactionReceivedEmail.ts

@@ -1,27 +0,0 @@
-import { backendLogger as logger } from '@/server/logger'
-import Decimal from 'decimal.js-light'
-import { sendEMail } from './sendEMail'
-import { transactionReceived } from './text/transactionReceived'
-
-export const sendTransactionReceivedEmail = (data: {
-  senderFirstName: string
-  senderLastName: string
-  recipientFirstName: string
-  recipientLastName: string
-  email: string
-  senderEmail: string
-  amount: Decimal
-  overviewURL: string
-}): Promise<boolean> => {
-  logger.info(
-    `sendEmail(): to=${data.recipientFirstName} ${data.recipientLastName}, 
-      <${data.email}>, 
-      subject=${transactionReceived.de.subject}, 
-      text=${transactionReceived.de.text(data)}`,
-  )
-  return sendEMail({
-    to: `${data.recipientFirstName} ${data.recipientLastName} <${data.email}>`,
-    subject: transactionReceived.de.subject,
-    text: transactionReceived.de.text(data),
-  })
-}

backend/src/mailer/text/accountActivation.ts

@@ -1,32 +0,0 @@
-export const accountActivation = {
-  de: {
-    subject: 'Gradido: E-Mail Überprüfung',
-    text: (data: {
-      link: string
-      firstName: string
-      lastName: string
-      email: string
-      duration: string
-      resendLink: string
-    }): string =>
-      `Hallo ${data.firstName} ${data.lastName},
-
-Deine E-Mail-Adresse wurde soeben bei Gradido registriert.
-
-Klicke bitte auf diesen Link, um die Registrierung abzuschließen und dein Gradido-Konto zu aktivieren:
-${data.link}
-oder kopiere den obigen Link in dein Browserfenster.
-
-Der Link hat eine Gültigkeit von ${data.duration
-        .replace('hours', 'Stunden')
-        .replace('minutes', 'Minuten')
-        .replace(
-          ' and ',
-          ' und ',
-        )}. Sollte die Gültigkeit des Links bereits abgelaufen sein, kannst du dir hier einen neuen Link schicken lassen, in dem du deine E-Mail-Adresse eingibst:
-${data.resendLink}
-
-Mit freundlichen Grüßen,
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/accountMultiRegistration.ts

@@ -1,25 +0,0 @@
-export const accountMultiRegistration = {
-  de: {
-    subject: 'Gradido: Erneuter Registrierungsversuch mit deiner E-Mail',
-    text: (data: {
-      firstName: string
-      lastName: string
-      email: string
-      resendLink: string
-    }): string =>
-      `Hallo ${data.firstName} ${data.lastName},
-
-Deine E-Mail-Adresse wurde soeben erneut benutzt, um bei Gradido ein Konto zu registrieren.
-Es existiert jedoch zu deiner E-Mail-Adresse schon ein Konto.
-
-Klicke bitte auf den folgenden Link, falls du dein Passwort vergessen haben solltest:
-${data.resendLink}
-oder kopiere den obigen Link in dein Browserfenster.
-
-Wenn du nicht derjenige bist, der sich versucht hat erneut zu registrieren, wende dich bitte an unseren support:
-https://gradido.net/de/contact/
-
-Mit freundlichen Grüßen,
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/contributionConfirmed.ts

@@ -1,30 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-export const contributionConfirmed = {
-  de: {
-    subject: 'Dein Gemeinwohl-Beitrag wurde bestätigt',
-    text: (data: {
-      senderFirstName: string
-      senderLastName: string
-      recipientFirstName: string
-      recipientLastName: string
-      contributionMemo: string
-      contributionAmount: Decimal
-      overviewURL: string
-    }): string =>
-      `Hallo ${data.recipientFirstName} ${data.recipientLastName},
-
-dein Gemeinwohl-Beitrag "${data.contributionMemo}" wurde soeben von ${data.senderFirstName} ${
-        data.senderLastName
-      } bestätigt und in deinem Gradido-Konto gutgeschrieben.
-
-Betrag: ${data.contributionAmount.toFixed(2).replace('.', ',')} GDD
-
-Link zu deinem Konto: ${data.overviewURL}
-
-Bitte antworte nicht auf diese E-Mail!
-
-Liebe Grüße
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/contributionMessageReceived.ts

@@ -1,28 +0,0 @@
-export const contributionMessageReceived = {
-  de: {
-    subject: 'Nachricht zu deinem Gemeinwohl-Beitrag',
-    text: (data: {
-      senderFirstName: string
-      senderLastName: string
-      recipientFirstName: string
-      recipientLastName: string
-      recipientEmail: string
-      senderEmail: string
-      contributionMemo: string
-      message: string
-      overviewURL: string
-    }): string =>
-      `Hallo ${data.recipientFirstName} ${data.recipientLastName},
-
-du hast zu deinem Gemeinwohl-Beitrag "${data.contributionMemo}" eine Nachricht von ${data.senderFirstName} ${data.senderLastName} erhalten.
-
-Um die Nachricht zu sehen und darauf zu antworten, gehe in deinem Gradido-Konto ins Menü "Gemeinschaft" auf den Tab "Meine Beiträge zum Gemeinwohl"!
-
-Link zu deinem Konto: ${data.overviewURL}
-
-Bitte antworte nicht auf diese E-Mail!
-
-Liebe Grüße
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/contributionRejected.ts

@@ -1,28 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-export const contributionRejected = {
-  de: {
-    subject: 'Dein Gemeinwohl-Beitrag wurde abgelehnt',
-    text: (data: {
-      senderFirstName: string
-      senderLastName: string
-      recipientFirstName: string
-      recipientLastName: string
-      contributionMemo: string
-      contributionAmount: Decimal
-      overviewURL: string
-    }): string =>
-      `Hallo ${data.recipientFirstName} ${data.recipientLastName},
-
-dein Gemeinwohl-Beitrag "${data.contributionMemo}" wurde von ${data.senderFirstName} ${data.senderLastName} abgelehnt.
-
-Um deine Gemeinwohl-Beiträge und dazugehörige Nachrichten zu sehen, gehe in deinem Gradido-Konto ins Menü "Gemeinschaft" auf den Tab "Meine Beiträge zum Gemeinwohl"!
-
-Link zu deinem Konto: ${data.overviewURL}
-
-Bitte antworte nicht auf diese E-Mail!
-
-Liebe Grüße
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/resetPassword.ts

@@ -1,30 +0,0 @@
-export const resetPassword = {
-  de: {
-    subject: 'Gradido: Passwort zurücksetzen',
-    text: (data: {
-      link: string
-      firstName: string
-      lastName: string
-      email: string
-      duration: string
-      resendLink: string
-    }): string =>
-      `Hallo ${data.firstName} ${data.lastName},
-
-Du oder jemand anderes hat für dieses Konto ein Zurücksetzen des Passworts angefordert.
-Wenn du es warst, klicke bitte auf den Link: ${data.link}
-oder kopiere den obigen Link in Dein Browserfenster.
-
-Der Link hat eine Gültigkeit von ${data.duration
-        .replace('hours', 'Stunden')
-        .replace('minutes', 'Minuten')
-        .replace(
-          ' and ',
-          ' und ',
-        )}. Sollte die Gültigkeit des Links bereits abgelaufen sein, kannst du dir hier einen neuen Link schicken lassen, in dem du deine E-Mail-Adresse eingibst:
-${data.resendLink}
-
-Mit freundlichen Grüßen,
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/transactionLinkRedeemed.ts

@@ -1,33 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-export const transactionLinkRedeemed = {
-  de: {
-    subject: 'Gradido-Link wurde eingelöst',
-    text: (data: {
-      email: string
-      senderFirstName: string
-      senderLastName: string
-      recipientFirstName: string
-      recipientLastName: string
-      senderEmail: string
-      amount: Decimal
-      memo: string
-      overviewURL: string
-    }): string =>
-      `Hallo ${data.recipientFirstName} ${data.recipientLastName},
-  
-${data.senderFirstName} ${data.senderLastName} (${
-        data.senderEmail
-      }) hat soeben deinen Link eingelöst.
-
-Betrag: ${data.amount.toFixed(2).replace('.', ',')} GDD,
-Memo: ${data.memo}
-
-Details zur Transaktion findest du in deinem Gradido-Konto: ${data.overviewURL}
-
-Bitte antworte nicht auf diese E-Mail!
-
-Liebe Grüße
-dein Gradido-Team`,
-  },
-}

backend/src/mailer/text/transactionReceived.ts

@@ -1,29 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-export const transactionReceived = {
-  de: {
-    subject: 'Du hast Gradidos erhalten',
-    text: (data: {
-      senderFirstName: string
-      senderLastName: string
-      recipientFirstName: string
-      recipientLastName: string
-      email: string
-      senderEmail: string
-      amount: Decimal
-      overviewURL: string
-    }): string =>
-      `Hallo ${data.recipientFirstName} ${data.recipientLastName},
-
-du hast soeben ${data.amount.toFixed(2).replace('.', ',')} GDD von ${data.senderFirstName} ${
-        data.senderLastName
-      } (${data.senderEmail}) erhalten.
-
-Details zur Transaktion findest du in deinem Gradido-Konto: ${data.overviewURL}
-
-Bitte antworte nicht auf diese E-Mail!
-
-Liebe Grüße
-dein Gradido-Team`,
-  },
-}

backend/src/util/time.ts

@@ -0,0 +1,16 @@
+export const getTimeDurationObject = (time: number): { hours?: number; minutes: number } => {
+  if (time > 60) {
+    return {
+      hours: Math.floor(time / 60),
+      minutes: time % 60,
+    }
+  }
+  return { minutes: time }
+}
+
+export const printTimeDuration = (duration: number): string => {
+  const time = getTimeDurationObject(duration)
+  const result = time.minutes > 0 ? `${time.minutes} minutes` : ''
+  if (time.hours) return `${time.hours} hours` + (result !== '' ? ` and ${result}` : '')
+  return result
+}

backend/src/util/utilities.ts

@@ -1,5 +1,16 @@
+import Decimal from 'decimal.js-light'
+import i18n from 'i18n'
+
 export const objectValuesToArray = (obj: { [x: string]: string }): Array<string> => {
   return Object.keys(obj).map(function (key) {
     return obj[key]
   })
 }
+
+export const decimalSeparatorByLanguage = (a: Decimal, language: string): string => {
+  const rememberLocaleToRestore = i18n.getLocale()
+  i18n.setLocale(language)
+  const result = a.toFixed(2).replace('.', i18n.__('general.decimalSeparator'))
+  i18n.setLocale(rememberLocaleToRestore)
+  return result
+}

backend/test/helpers.test.ts

@@ -0,0 +1,7 @@
+import { contributionDateFormatter } from '@test/helpers'
+
+describe('contributionDateFormatter', () => {
+  it('formats the date correctly', () => {
+    expect(contributionDateFormatter(new Date('Thu Feb 29 2024 13:12:11'))).toEqual('2/29/2024')
+  })
+})

backend/test/helpers.ts

@@ -5,6 +5,7 @@ import { createTestClient } from 'apollo-server-testing'
 import createServer from '../src/server/createServer'
 import { initialize } from '@dbTools/helpers'
 import { entities } from '@entity/index'
+import { i18n, logger } from './testSetup'
 
 export const headerPushMock = jest.fn((t) => {
   context.token = t.value
@@ -26,8 +27,8 @@ export const cleanDB = async () => {
   }
 }
 
-export const testEnvironment = async (logger?: any, localization?: any) => {
-  const server = await createServer(context, logger, localization)
+export const testEnvironment = async (testLogger: any = logger, testI18n: any = i18n) => {
+  const server = await createServer(context, testLogger, testI18n)
   const con = server.con
   const testClient = createTestClient(server.apollo)
   const mutate = testClient.mutate

backend/test/testSetup.ts

@@ -1,6 +1,10 @@
+import CONFIG from '@/config'
 import { backendLogger as logger } from '@/server/logger'
 import { i18n } from '@/server/localization'
 
+CONFIG.EMAIL = true
+CONFIG.EMAIL_TEST_MODUS = false
+
 jest.setTimeout(1000000)
 
 jest.mock('@/server/logger', () => {

backend/tsconfig.json

@@ -51,6 +51,7 @@
       "@arg/*": ["src/graphql/arg/*"],
       "@enum/*": ["src/graphql/enum/*"],
       "@model/*": ["src/graphql/model/*"],
+      "@union/*": ["src/graphql/union/*"],
       "@repository/*": ["src/typeorm/repository/*"],
       "@test/*": ["test/*"],
       /* external */

database/migrations/0055-consistent_deleted_users.ts

@@ -0,0 +1,16 @@
+/* MIGRATION TO soft delete user contacts of soft deleted 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(`
+    UPDATE user_contacts LEFT JOIN users ON users.email_id = user_contacts.id
+    SET user_contacts.deleted_at = users.deleted_at
+    WHERE user_contacts.deleted_at IS NULL
+    AND users.deleted_at IS NOT NULL;`)
+}
+
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+export async function downgrade(queryFn: (query: string, values?: any[]) => Promise<Array<any>>) {}

docker-compose.yml

@@ -108,7 +108,7 @@ services:
     #env_file:
     #  - ./frontend/.env
     volumes:
-      # <host_machine_directy>:<container_directory> – mirror bidirectional path in local context with path in Docker container
+      # <host_machine_directory>:<container_directory> – mirror bidirectional path in local context with path in Docker container
       - ./logs/backend:/logs/backend
 
   ########################################################