diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index ae4570622..15a736630 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -509,7 +509,7 @@ jobs: - name: backend | docker-compose run: docker-compose -f docker-compose.yml -f docker-compose.test.yml up --detach --no-deps mariadb database - name: backend Unit tests | test - run: cd database && yarn && cd ../backend && yarn && yarn test + run: cd database && yarn && yarn build && cd ../backend && yarn && yarn CI_worklfow_test # run: docker-compose -f docker-compose.yml -f docker-compose.test.yml exec -T backend yarn test ########################################################################## # COVERAGE CHECK BACKEND ################################################# @@ -520,7 +520,7 @@ jobs: report_name: Coverage Backend type: lcov result_path: ./backend/coverage/lcov.info - min_coverage: 37 + min_coverage: 40 token: ${{ github.token }} ############################################################################## diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..3b6641073 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "git.ignoreLimitWarning": true +} \ No newline at end of file diff --git a/admin/src/components/ConfirmRegisterMailFormular.spec.js b/admin/src/components/ConfirmRegisterMailFormular.spec.js index 8872128e9..705a185a3 100644 --- a/admin/src/components/ConfirmRegisterMailFormular.spec.js +++ b/admin/src/components/ConfirmRegisterMailFormular.spec.js @@ -8,6 +8,7 @@ const toastSuccessMock = jest.fn() const toastErrorMock = jest.fn() const mocks = { + $t: jest.fn((t) => t), $apollo: { mutate: apolloMutateMock, }, @@ -52,9 +53,7 @@ describe('ConfirmRegisterMailFormular', () => { }) it('toasts a success message', () => { - expect(toastSuccessMock).toBeCalledWith( - 'Erfolgreich senden der Confirmation Link an die E-Mail des Users! bob@baumeister.de', - ) + expect(toastSuccessMock).toBeCalledWith('unregister_mail.success') }) }) @@ -66,9 +65,7 @@ describe('ConfirmRegisterMailFormular', () => { }) it('toasts an error message', () => { - expect(toastErrorMock).toBeCalledWith( - 'Fehler beim senden des confirmation link an den Benutzer: OUCH!', - ) + expect(toastErrorMock).toBeCalledWith('unregister_mail.error') }) }) }) diff --git a/admin/src/components/ConfirmRegisterMailFormular.vue b/admin/src/components/ConfirmRegisterMailFormular.vue index 866e8a487..5052a8a3e 100644 --- a/admin/src/components/ConfirmRegisterMailFormular.vue +++ b/admin/src/components/ConfirmRegisterMailFormular.vue @@ -2,17 +2,15 @@
- Die letzte Email wurde am - {{ dateLastSend }} Uhr - an das Mitglied ({{ email }}) gesendet. + {{ $t('unregister_mail.text', { date: dateLastSend, mail: email }) }}
- + - Registrierungs-Email bestätigen, jetzt senden + {{ $t('unregister_mail.button') }} @@ -42,14 +40,10 @@ export default { }, }) .then(() => { - this.$toasted.success( - 'Erfolgreich senden der Confirmation Link an die E-Mail des Users! ' + this.email, - ) + this.$toasted.success(this.$t('unregister_mail.success', { email: this.email })) }) .catch((error) => { - this.$toasted.error( - 'Fehler beim senden des confirmation link an den Benutzer: ' + error.message, - ) + this.$toasted.error(this.$t('unregister_mail.error', { message: error.message })) }) }, }, diff --git a/admin/src/components/ContentFooter.vue b/admin/src/components/ContentFooter.vue index ade4e0a83..1e7e20f9e 100644 --- a/admin/src/components/ContentFooter.vue +++ b/admin/src/components/ContentFooter.vue @@ -3,8 +3,8 @@

- Gradido Akademie Adminkonsole -
Version: 0.0.1
+ {{ $t('gradido_admin_footer') }} +
Version: 1.0.0
diff --git a/admin/src/components/CreationFormular.spec.js b/admin/src/components/CreationFormular.spec.js index 5b733f4e0..5b0ac09f5 100644 --- a/admin/src/components/CreationFormular.spec.js +++ b/admin/src/components/CreationFormular.spec.js @@ -21,6 +21,7 @@ const toastedErrorMock = jest.fn() const toastedSuccessMock = jest.fn() const mocks = { + $t: jest.fn((t) => t), $moment: jest.fn(() => { return { format: jest.fn((m) => m), diff --git a/admin/src/components/CreationFormular.vue b/admin/src/components/CreationFormular.vue index 6a4bcc619..d1e1c4b06 100644 --- a/admin/src/components/CreationFormular.vue +++ b/admin/src/components/CreationFormular.vue @@ -1,10 +1,10 @@ diff --git a/admin/src/components/UserTable.spec.js b/admin/src/components/UserTable.spec.js index 3db0131a3..e25f53015 100644 --- a/admin/src/components/UserTable.spec.js +++ b/admin/src/components/UserTable.spec.js @@ -13,8 +13,12 @@ describe('UserTable', () => { creation: [], } + const mocks = { + $t: jest.fn((t) => t), + } + const Wrapper = () => { - return mount(UserTable, { localVue, propsData }) + return mount(UserTable, { localVue, propsData, mocks }) } describe('mount', () => { diff --git a/admin/src/components/UserTable.vue b/admin/src/components/UserTable.vue index 3a82663ce..3f5393412 100644 --- a/admin/src/components/UserTable.vue +++ b/admin/src/components/UserTable.vue @@ -248,21 +248,18 @@ export default { this.overlayItem = item if (bookmarkType === 'remove') { - this.overlayText.header = 'Achtung! Schöpfung löschen!' - this.overlayText.text1 = - 'Nach dem Löschen gibt es keine Möglichkeit mehr diesen Datensatz wiederherzustellen. Es wird aber der gesamte Vorgang in der Logdatei als Übersicht gespeichert.' - this.overlayText.text2 = 'Willst du die vorgespeicherte Schöpfung wirklich löschen? ' - this.overlayText.button_ok = 'Ja, Schöpfung löschen!' - this.overlayText.button_cancel = 'Nein, nicht löschen.' + this.overlayText.header = this.$t('overlay.remove.title') + this.overlayText.text1 = this.$t('overlay.remove.text') + this.overlayText.text2 = this.$t('overlay.remove.question') + this.overlayText.button_ok = this.$t('overlay.remove.yes') + this.overlayText.button_cancel = this.$t('overlay.remove.no') } if (bookmarkType === 'confirm') { - this.overlayText.header = 'Schöpfung bestätigen!' - this.overlayText.text1 = - 'Nach dem Speichern ist der Datensatz nicht mehr änderbar und kann auch nicht mehr gelöscht werden. Bitte überprüfe genau, dass alles stimmt.' - this.overlayText.text2 = - 'Willst du diese vorgespeicherte Schöpfung wirklich vollziehen und entgültig speichern?' - this.overlayText.button_ok = 'Ja, Schöpfung speichern und bestätigen!' - this.overlayText.button_cancel = 'Nein, nicht speichern.' + this.overlayText.header = this.$t('overlay.confirm.title') + this.overlayText.text1 = this.$t('overlay.confirm.text') + this.overlayText.text2 = this.$t('overlay.confirm.question') + this.overlayText.button_ok = this.$t('overlay.confirm.yes') + this.overlayText.button_cancel = this.$t('overlay.confirm.no') } }, overlayOK(bookmarkType, item) { diff --git a/admin/src/locales/de.json b/admin/src/locales/de.json index 96a409c60..b2f0e427d 100644 --- a/admin/src/locales/de.json +++ b/admin/src/locales/de.json @@ -1,4 +1,65 @@ { - "not_open_creations": "keine offene Schöpfungen", - "open_creations": "offene Schöpfungen" + "bookmark": "bookmark", + "confirmed": "bestätigt", + "creation_form": { + "creation_for": "Schöpfung für ", + "enter_text": "Text eintragen", + "form": "Schöpfungsformular", + "min_characters": "Mindestens 10 Zeichen eingeben", + "reset": "Zurücksetzen", + "select_month": "Monat auswählen", + "select_value": "Betrag auswählen", + "submit_creation": "Schöpfung einreichen", + "toasted": "Offene Schöpfung ({value} GDD) für {email} wurde gespeichert und liegt zur Bestätigung bereit", + "toasted_update": "`Offene Schöpfung {value} GDD) für {email} wurde geändert und liegt zur Bestätigung bereit", + "update_creation": "Schöpfung aktualisieren" + }, + "details": "Details", + "e_mail": "E-Mail", + "firstname": "Vorname", + "gradido_admin_footer": "Gradido Akademie Adminkonsole", + "hide_details": "Details verbergen von", + "lastname": "Nachname", + "multiple_creation_text": "Bitte wähle ein oder mehrere Mitglieder aus für die du Schöpfen möchtest.", + "navbar": { + "logout": "Abmelden", + "multi_creation": "Mehrfachschöpfung", + "open_creation": "Offene Schöpfungen", + "overview": "Übersicht", + "user_search": "Nutzersuche", + "wallet": "Wallet" + }, + "not_open_creations": "Keine offenen Schöpfungen", + "open_creation": "Offene Schöpfung", + "open_creations": "Offene Schöpfungen", + "overlay": { + "confirm": { + "no": "Nein, nicht speichern.", + "question": "Willst du diese vorgespeicherte Schöpfung wirklich vollziehen und entgültig speichern?", + "text": "Nach dem Speichern ist der Datensatz nicht mehr änderbar und kann auch nicht mehr gelöscht werden. Bitte überprüfe genau, dass alles stimmt.", + "title": "Schöpfung bestätigen!", + "yes": "Ja, Schöpfung bestätigen und speichern!" + }, + "remove": { + "no": "Nein, nicht löschen.", + "question": "Willst du die vorgespeicherte Schöpfung wirklich löschen?", + "text": "Nach dem Löschen gibt es keine Möglichkeit mehr diesen Datensatz wiederherzustellen. Es wird aber der gesamte Vorgang in der Logdatei als Übersicht gespeichert.", + "title": "Achtung! Schöpfung löschen!", + "yes": "Ja, Schöpfung löschen!" + } + }, + "remove": "Entfernen", + "transaction": "Transaktion", + "transactionlist": { + "title": "Alle geschöpften Transaktionen für den Nutzer" + }, + "unregistered_emails": "Unregistrierte E-Mails", + "unregister_mail": { + "button": "Registrierungs-Email bestätigen, jetzt senden", + "error": "Fehler beim Senden des Bestätigungs-Links an den Benutzer: {message}", + "info": "Email bestätigen, wiederholt senden an:", + "success": "Erfolgreiches Senden des Bestätigungs-Links an die E-Mail des Nutzers! ({email})", + "text": " Die letzte Email wurde am {date} Uhr an das Mitglied ({mail}) gesendet." + }, + "user_search": "Nutzer-Suche" } diff --git a/admin/src/locales/en.json b/admin/src/locales/en.json index 20ab609e0..398f4b5f6 100644 --- a/admin/src/locales/en.json +++ b/admin/src/locales/en.json @@ -1,4 +1,65 @@ { + "bookmark": "Remember", + "confirmed": "confirmed", + "creation_form": { + "creation_for": "Creation for ", + "enter_text": "Enter text", + "form": "Creation form", + "min_characters": "Enter at least 10 characters", + "reset": "Reset", + "select_month": "Select month", + "select_value": "Select amount", + "submit_creation": "Submit creation", + "toasted": "Open creation ({value} GDD) for {email} has been saved and is ready for confirmation.", + "toasted_update": "Open creation {value} GDD) for {email} has been changed and is ready for confirmation.", + "update_creation": "Creation update" + }, + "details": "Details", + "e_mail": "E-Mail", + "firstname": "Firstname", + "gradido_admin_footer": "Gradido Academy Admin Console", + "hide_details": "Hide details from", + "lastname": "Lastname", + "multiple_creation_text": "Please select one or more members for which you would like to perform creations.", + "navbar": { + "logout": "Logout", + "multi_creation": "Multiple creation", + "open_creation": "Open creations", + "overview": "Overview", + "user_search": "User search", + "wallet": "Wallet" + }, "not_open_creations": "No open creations", - "open_creations": "Open creations" + "open_creation": "Open creation", + "open_creations": "Open creations", + "overlay": { + "confirm": { + "no": "No, do not save.", + "question": "Do you really want to carry out and finally save this pre-stored creation?", + "text": "After saving, the record can no longer be changed or deleted. Please check carefully that everything is correct.", + "title": "Confirm creation!", + "yes": "Yes, confirm and save creation!" + }, + "remove": { + "no": "No, do not delete.", + "question": "Do you really want to delete the pre-stored creation?", + "text": "After deletion, there is no possibility to restore this data record. However, the entire process is saved in the log file as an overview.", + "title": "Attention! Delete creation!", + "yes": "Yes, delete creation!" + } + }, + "remove": "Remove", + "transaction": "Transaction", + "transactionlist": { + "title": "All creation-transactions for the user" + }, + "unregistered_emails": "Unregistered e-mails", + "unregister_mail": { + "button": "Confirm registration email, send now", + "error": "Error sending the confirmation link to the user: {message}", + "info": "Confirm email, send repeatedly to:", + "success": "Successfully send the confirmation link to the user's email! ({email})", + "text": " The last email was sent to the member ({mail}) on {date} clock." + }, + "user_search": "User search" } diff --git a/admin/src/pages/Creation.spec.js b/admin/src/pages/Creation.spec.js index 65e56ca33..073b22c0e 100644 --- a/admin/src/pages/Creation.spec.js +++ b/admin/src/pages/Creation.spec.js @@ -28,6 +28,7 @@ const apolloQueryMock = jest.fn().mockResolvedValue({ const toastErrorMock = jest.fn() const mocks = { + $t: jest.fn((t) => t), $apollo: { query: apolloQueryMock, }, diff --git a/admin/src/pages/Creation.vue b/admin/src/pages/Creation.vue index e8651357e..4d6dca920 100644 --- a/admin/src/pages/Creation.vue +++ b/admin/src/pages/Creation.vue @@ -31,7 +31,7 @@ @update-item="updateItem" />
- Bitte wähle ein oder Mehrere Mitglieder aus für die du Schöpfen möchtest + {{ $t('multiple_creation_text') }}
t), $store: { commit: storeCommitMock, }, diff --git a/admin/src/pages/Overview.spec.js b/admin/src/pages/Overview.spec.js index b0b8dc6fb..b3d720d5c 100644 --- a/admin/src/pages/Overview.spec.js +++ b/admin/src/pages/Overview.spec.js @@ -22,6 +22,7 @@ const apolloQueryMock = jest.fn().mockResolvedValue({ const storeCommitMock = jest.fn() const mocks = { + $t: jest.fn((t) => t), $apollo: { query: apolloQueryMock, }, @@ -31,7 +32,6 @@ const mocks = { openCreations: 2, }, }, - $t: jest.fn((t) => t), } describe('Overview', () => { diff --git a/admin/src/pages/UserSearch.spec.js b/admin/src/pages/UserSearch.spec.js index 63fcefb5b..473b2bbdc 100644 --- a/admin/src/pages/UserSearch.spec.js +++ b/admin/src/pages/UserSearch.spec.js @@ -20,6 +20,7 @@ const apolloQueryMock = jest.fn().mockResolvedValue({ const toastErrorMock = jest.fn() const mocks = { + $t: jest.fn((t) => t), $apollo: { query: apolloQueryMock, }, diff --git a/admin/src/pages/UserSearch.vue b/admin/src/pages/UserSearch.vue index 186f2c8ce..2c8b289e0 100644 --- a/admin/src/pages/UserSearch.vue +++ b/admin/src/pages/UserSearch.vue @@ -3,15 +3,15 @@
- Anzeigen aller nicht registrierten E-Mails. + {{ $t('unregistered_emails') }}
- + @@ -37,12 +37,12 @@ export default { return { showArrays: false, fields: [ - { key: 'email', label: 'Email' }, - { key: 'firstName', label: 'Firstname' }, - { key: 'lastName', label: 'Lastname' }, + { key: 'email', label: this.$t('e_mail') }, + { key: 'firstName', label: this.$t('firstname') }, + { key: 'lastName', label: this.$t('lastname') }, { key: 'creation', - label: 'Open creations', + label: this.$t('open_creation'), formatter: (value, key, item) => { return ( ` @@ -65,9 +65,9 @@ export default { ) }, }, - { key: 'show_details', label: 'Details' }, - { key: 'confirm_mail', label: 'Mail' }, - { key: 'transactions_list', label: 'Transaction' }, + { key: 'show_details', label: this.$t('details') }, + { key: 'confirm_mail', label: this.$t('confirmed') }, + { key: 'transactions_list', label: this.$t('transaction') }, ], searchResult: [], massCreation: [], diff --git a/backend/jest.config.js b/backend/jest.config.js index 3cee980c5..9d99c68f6 100644 --- a/backend/jest.config.js +++ b/backend/jest.config.js @@ -5,6 +5,11 @@ module.exports = { collectCoverage: true, collectCoverageFrom: ['src/**/*.ts', '!**/node_modules/**'], moduleNameMapper: { - '@entity/(.*)': '/../database/entity/$1', + '@entity/(.*)': '/../database/build/entity/$1', + // This is hack to fix a problem with the library `ts-mysql-migrate` which does differentiate between its ts/js state + '@dbTools/(.*)': + process.env.NODE_ENV === 'development' + ? '/../database/src/$1' + : '/../database/build/src/$1', }, } diff --git a/backend/package.json b/backend/package.json index e573a2704..c9314f0fd 100644 --- a/backend/package.json +++ b/backend/package.json @@ -13,7 +13,8 @@ "start": "node build/index.js", "dev": "nodemon -w src --ext ts --exec ts-node src/index.ts", "lint": "eslint . --ext .js,.ts", - "test": "jest --runInBand --coverage " + "CI_worklfow_test": "jest --runInBand --coverage ", + "test": "NODE_ENV=development jest --runInBand --coverage " }, "dependencies": { "@types/jest": "^27.0.2", @@ -59,6 +60,7 @@ "typescript": "^4.3.4" }, "_moduleAliases": { - "@entity": "../database/build/entity" + "@entity": "../database/build/entity", + "@dbTools": "../database/build/src" } } diff --git a/backend/src/graphql/resolver/AdminResolver.ts b/backend/src/graphql/resolver/AdminResolver.ts index f441e5383..f7d675aaa 100644 --- a/backend/src/graphql/resolver/AdminResolver.ts +++ b/backend/src/graphql/resolver/AdminResolver.ts @@ -335,7 +335,5 @@ function isCreationValid(creations: number[], amount: number, creationDate: Date async function hasActivatedEmail(email: string): Promise { const repository = getCustomRepository(LoginUserRepository) const user = await repository.findByEmail(email) - let emailActivate = false - if (user) emailActivate = user.emailChecked return user ? user.emailChecked : false } diff --git a/backend/src/graphql/resolver/UserResolver.test.ts b/backend/src/graphql/resolver/UserResolver.test.ts new file mode 100644 index 000000000..d0c144e22 --- /dev/null +++ b/backend/src/graphql/resolver/UserResolver.test.ts @@ -0,0 +1,232 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ +/* eslint-disable @typescript-eslint/explicit-module-boundary-types */ + +import { createTestClient } from 'apollo-server-testing' +import gql from 'graphql-tag' +import { GraphQLError } from 'graphql' +import createServer from '../../server/createServer' +import { resetDB, initialize } from '@dbTools/helpers' +import { getRepository } from 'typeorm' +import { LoginUser } from '@entity/LoginUser' +import { LoginUserBackup } from '@entity/LoginUserBackup' +import { LoginEmailOptIn } from '@entity/LoginEmailOptIn' +import { User } from '@entity/User' +import CONFIG from '../../config' +import { sendEMail } from '../../util/sendEMail' + +jest.mock('../../util/sendEMail', () => { + return { + __esModule: true, + sendEMail: jest.fn(), + } +}) + +let mutate: any +let con: any + +beforeAll(async () => { + const server = await createServer({}) + con = server.con + mutate = createTestClient(server.apollo).mutate + await initialize() + await resetDB() +}) + +describe('UserResolver', () => { + describe('createUser', () => { + const variables = { + email: 'peter@lustig.de', + firstName: 'Peter', + lastName: 'Lustig', + language: 'de', + publisherId: 1234, + } + + const mutation = gql` + mutation ( + $email: String! + $firstName: String! + $lastName: String! + $language: String! + $publisherId: Int + ) { + createUser( + email: $email + firstName: $firstName + lastName: $lastName + language: $language + publisherId: $publisherId + ) + } + ` + + let result: any + let emailOptIn: string + let newUser: User + + beforeAll(async () => { + result = await mutate({ mutation, variables }) + }) + + afterAll(async () => { + await resetDB() + }) + + it('returns success', () => { + expect(result).toEqual(expect.objectContaining({ data: { createUser: 'success' } })) + }) + + describe('valid input data', () => { + let loginUser: LoginUser[] + let user: User[] + let loginUserBackup: LoginUserBackup[] + let loginEmailOptIn: LoginEmailOptIn[] + beforeAll(async () => { + loginUser = await getRepository(LoginUser).createQueryBuilder('login_user').getMany() + user = await getRepository(User).createQueryBuilder('state_user').getMany() + loginUserBackup = await getRepository(LoginUserBackup) + .createQueryBuilder('login_user_backup') + .getMany() + loginEmailOptIn = await getRepository(LoginEmailOptIn) + .createQueryBuilder('login_email_optin') + .getMany() + newUser = user[0] + emailOptIn = loginEmailOptIn[0].verificationCode.toString() + }) + + describe('filling all tables', () => { + it('saves the user in login_user table', () => { + expect(loginUser).toEqual([ + { + id: expect.any(Number), + email: 'peter@lustig.de', + firstName: 'Peter', + lastName: 'Lustig', + username: '', + description: '', + password: '0', + pubKey: null, + privKey: null, + emailHash: expect.any(Buffer), + createdAt: expect.any(Date), + emailChecked: false, + passphraseShown: false, + language: 'de', + disabled: false, + groupId: 1, + publisherId: 1234, + }, + ]) + }) + + it('saves the user in state_user table', () => { + expect(user).toEqual([ + { + id: expect.any(Number), + indexId: 0, + groupId: 0, + pubkey: expect.any(Buffer), + email: 'peter@lustig.de', + firstName: 'Peter', + lastName: 'Lustig', + username: '', + disabled: false, + }, + ]) + }) + + it('saves the user in login_user_backup table', () => { + expect(loginUserBackup).toEqual([ + { + id: expect.any(Number), + passphrase: expect.any(String), + userId: loginUser[0].id, + mnemonicType: 2, + }, + ]) + }) + + it('creates an email optin', () => { + expect(loginEmailOptIn).toEqual([ + { + id: expect.any(Number), + userId: loginUser[0].id, + verificationCode: expect.any(String), + emailOptInTypeId: 1, + createdAt: expect.any(Date), + resendCount: 0, + updatedAt: expect.any(Date), + }, + ]) + }) + }) + }) + + describe('account activation email', () => { + it('sends an account activation email', () => { + const activationLink = CONFIG.EMAIL_LINK_VERIFICATION.replace(/\$1/g, emailOptIn) + expect(sendEMail).toBeCalledWith({ + from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`, + to: `${newUser.firstName} ${newUser.lastName} <${newUser.email}>`, + subject: 'Gradido: E-Mail Überprüfung', + text: + expect.stringContaining(`Hallo ${newUser.firstName} ${newUser.lastName},`) && + expect.stringContaining(activationLink), + }) + }) + }) + + describe('email already exists', () => { + it('throws an error', async () => { + await expect(mutate({ mutation, variables })).resolves.toEqual( + expect.objectContaining({ + errors: [new GraphQLError('User already exists.')], + }), + ) + }) + }) + + describe('unknown language', () => { + it('sets "de" as default language', async () => { + await mutate({ + mutation, + variables: { ...variables, email: 'bibi@bloxberg.de', language: 'es' }, + }) + await expect( + getRepository(LoginUser).createQueryBuilder('login_user').getMany(), + ).resolves.toEqual( + expect.arrayContaining([ + expect.objectContaining({ + email: 'bibi@bloxberg.de', + language: 'de', + }), + ]), + ) + }) + }) + + describe('no publisher id', () => { + it('sets publisher id to null', async () => { + await mutate({ + mutation, + variables: { ...variables, email: 'raeuber@hotzenplotz.de', publisherId: undefined }, + }) + await expect( + getRepository(LoginUser).createQueryBuilder('login_user').getMany(), + ).resolves.toEqual( + expect.arrayContaining([ + expect.objectContaining({ + email: 'raeuber@hotzenplotz.de', + publisherId: null, + }), + ]), + ) + }) + }) + }) +}) + +afterAll(async () => { + await resetDB(true) + await con.close() +}) diff --git a/backend/src/graphql/resolver/UserResolver.ts b/backend/src/graphql/resolver/UserResolver.ts index 20bd01cec..2f98a2f6f 100644 --- a/backend/src/graphql/resolver/UserResolver.ts +++ b/backend/src/graphql/resolver/UserResolver.ts @@ -26,6 +26,7 @@ import { signIn } from '../../apis/KlicktippController' import { RIGHTS } from '../../auth/RIGHTS' import { ServerUserRepository } from '../../typeorm/repository/ServerUser' import { ROLE_ADMIN } from '../../auth/ROLES' +import { randomBytes } from 'crypto' const EMAIL_OPT_IN_RESET_PASSWORD = 2 const EMAIL_OPT_IN_REGISTER = 1 @@ -432,7 +433,7 @@ export class UserResolver { dbUser.lastName = lastName dbUser.username = username // TODO this field has no null allowed unlike the loginServer table - dbUser.pubkey = Buffer.alloc(32, 0) // default to 0000... + dbUser.pubkey = Buffer.from(randomBytes(32)) // Buffer.alloc(32, 0) default to 0000... // dbUser.pubkey = keyPair[0] await queryRunner.manager.save(dbUser).catch((er) => { @@ -471,13 +472,13 @@ export class UserResolver { return 'success' } - private async sendAccountActivationEmail( + private sendAccountActivationEmail( activationLink: string, firstName: string, lastName: string, email: string, - ) { - const emailSent = await sendEMail({ + ): Promise { + return sendEMail({ from: `Gradido (nicht antworten) <${CONFIG.EMAIL_SENDER}>`, to: `${firstName} ${lastName} <${email}>`, subject: 'Gradido: E-Mail Überprüfung', @@ -492,7 +493,6 @@ export class UserResolver { Mit freundlichen Grüßen, dein Gradido-Team`, }) - return emailSent } @Mutation(() => Boolean) diff --git a/backend/src/middleware/userResolverMiddleware.ts b/backend/src/middleware/userResolverMiddleware.ts deleted file mode 100644 index e69de29bb..000000000 diff --git a/backend/tsconfig.json b/backend/tsconfig.json index 73e00a1a0..eabdc75b0 100644 --- a/backend/tsconfig.json +++ b/backend/tsconfig.json @@ -47,7 +47,8 @@ // "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */ // "baseUrl": "./", /* Base directory to resolve non-absolute module names. */ "paths": { /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */ - "@entity/*": ["../database/entity/*"] + "@entity/*": ["../database/entity/*"], + "@dbTools/*": ["../database/src/*"] }, // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */ // "typeRoots": [], /* List of folders to include type definitions from. */ diff --git a/database/.env.dist b/database/.env.dist index 644dcaaf4..689e4f509 100644 --- a/database/.env.dist +++ b/database/.env.dist @@ -4,6 +4,5 @@ DB_USER=root DB_PASSWORD= DB_DATABASE=gradido_community MIGRATIONS_TABLE=migrations -MIGRATIONS_DIRECTORY=./migrations/ TYPEORM_SEEDING_FACTORIES=src/factories/**/*{.ts,.js} diff --git a/database/build/.env.dist b/database/build/.env.dist deleted file mode 100644 index 505546e1b..000000000 --- a/database/build/.env.dist +++ /dev/null @@ -1,2 +0,0 @@ -// For production you need to put your env file in here. -// Please copy the dist file from the root folder in here and rename it to .env \ No newline at end of file diff --git a/database/package.json b/database/package.json index 7ff5c60d3..515fbcd74 100644 --- a/database/package.json +++ b/database/package.json @@ -10,9 +10,9 @@ "scripts": { "build": "tsc --build", "clean": "tsc --build --clean", - "up": "cd build && node src/index.js up", - "down": "cd build && node src/index.js down", - "reset": "cd build && node src/index.js reset", + "up": "node build/src/index.js up", + "down": "node build/src/index.js down", + "reset": "node build/src/index.js reset", "dev_up": "ts-node src/index.ts up", "dev_down": "ts-node src/index.ts down", "dev_reset": "ts-node src/index.ts reset", diff --git a/database/src/config/index.ts b/database/src/config/index.ts index 908d40311..2dde06c96 100644 --- a/database/src/config/index.ts +++ b/database/src/config/index.ts @@ -13,7 +13,6 @@ const database = { const migrations = { MIGRATIONS_TABLE: process.env.MIGRATIONS_TABLE || 'migrations', - MIGRATIONS_DIRECTORY: process.env.MIGRATIONS_DIRECTORY || './migrations/', } const CONFIG = { ...database, ...migrations } diff --git a/database/src/helpers.ts b/database/src/helpers.ts new file mode 100644 index 000000000..710094548 --- /dev/null +++ b/database/src/helpers.ts @@ -0,0 +1,34 @@ +import CONFIG from './config' +import { createPool, PoolConfig } from 'mysql' +import { Migration } from 'ts-mysql-migrate' +import path from 'path' + +const poolConfig: PoolConfig = { + host: CONFIG.DB_HOST, + port: CONFIG.DB_PORT, + user: CONFIG.DB_USER, + password: CONFIG.DB_PASSWORD, + database: CONFIG.DB_DATABASE, +} + +// Pool? +const pool = createPool(poolConfig) + +// Create & Initialize Migrations +const migration = new Migration({ + conn: pool, + tableName: CONFIG.MIGRATIONS_TABLE, + silent: true, + dir: path.join(__dirname, '..', 'migrations'), +}) + +const initialize = async (): Promise => { + await migration.initialize() +} + +const resetDB = async (closePool = false): Promise => { + await migration.reset() // use for resetting database + if (closePool) pool.end() +} + +export { resetDB, pool, migration, initialize } diff --git a/database/src/index.ts b/database/src/index.ts index 94566c9f5..488d098d3 100644 --- a/database/src/index.ts +++ b/database/src/index.ts @@ -1,7 +1,4 @@ import 'reflect-metadata' -import { createPool, PoolConfig } from 'mysql' -import { Migration } from 'ts-mysql-migrate' -import CONFIG from './config' import prepare from './prepare' import connection from './typeorm/connection' import { useSeeding, runSeeder } from 'typeorm-seeding' @@ -10,30 +7,12 @@ import { CreateBibiBloxbergSeed } from './seeds/users/bibi-bloxberg.seed' import { CreateRaeuberHotzenplotzSeed } from './seeds/users/raeuber-hotzenplotz.seed' import { CreateBobBaumeisterSeed } from './seeds/users/bob-baumeister.seed' import { DecayStartBlockSeed } from './seeds/decay-start-block.seed' +import { resetDB, pool, migration } from './helpers' const run = async (command: string) => { // Database actions not supported by our migration library await prepare() - // Database connection for Migrations - const poolConfig: PoolConfig = { - host: CONFIG.DB_HOST, - port: CONFIG.DB_PORT, - user: CONFIG.DB_USER, - password: CONFIG.DB_PASSWORD, - database: CONFIG.DB_DATABASE, - } - - // Pool? - const pool = createPool(poolConfig) - - // Create & Initialize Migrations - const migration = new Migration({ - conn: pool, - tableName: CONFIG.MIGRATIONS_TABLE, - dir: CONFIG.MIGRATIONS_DIRECTORY, - }) - // Database connection for TypeORM const con = await connection() if (!con || !con.isConnected) { @@ -52,7 +31,7 @@ const run = async (command: string) => { break case 'reset': // TODO protect from production - await migration.reset() // use for resetting database + await resetDB() // use for resetting database break case 'seed': // TODO protect from production diff --git a/docu/Concepts/BusinessRequirements/BenutzerVerwaltung.md b/docu/Concepts/BusinessRequirements/BenutzerVerwaltung.md index a78f84238..9bb495742 100644 --- a/docu/Concepts/BusinessRequirements/BenutzerVerwaltung.md +++ b/docu/Concepts/BusinessRequirements/BenutzerVerwaltung.md @@ -2,25 +2,39 @@ Benutzer -* * - * natürliche Person = TRUE (Flag für Schöpfungserlaubnis Human) - * Vorname - * Nachname - * natürliche Person = FALSE (Flag für Schöpfungserlaubnis Human) - * Projekt/Firmenname/Organisation/Verein... - * Benutzername - * Emailadresse - * Konto - * Trustlevel (Zukunft) +* natürliche Person = TRUE (Flag für Schöpfungserlaubnis Human) + * Vorname + * Nachname +* natürliche Person = FALSE (Flag für Schöpfungserlaubnis Human) -Gradido-ID als Ersatz für Email-Adresse : server/nutzername + * Projekt/Firmenname/Organisation/Verein... +* Benutzername / useralias +* Emailadresse +* Konto +* Trustlevel (Zukunft) + +## Gradido-ID + +Die GradidoID oder auch Username dient zur eindeutigen Identifizierung eines Nutzers. Sie soll einerseits *human readable* , aber auch die maschinelle Weiterverarbeitung bzw. Nutzung ermöglichen. Daher werden folgende Regeln festgelegt: + +Pattern: ``/`` + +* `` + - Zeichen, die in einer URL erlaubt sind: + * A-Z, a-z, 0-9 + * '-', '.', '_', '~' +* ``: + - mindestens 5 Zeichen + * alphanumerisch + * keine Umlaute + * - und \_ sind nur zwischen sonst gültigen Zeichen erlaubt (RegEx: [a-zA-Z0-9]-|_[a-zA-Z0-9]) + - Blacklist für Schlüsselworte, die frei definiert werden können + - vordefinierte/reservierte System relevante Namen dürfen maximal aus 4 Zeichen bestehen -Nutzername ist pro server eindeutig Nutzerprofil mit Bild und persönlichen Angeboten - ## Anwendungsfälle ### neuen Benutzer anlegen diff --git a/docu/Concepts/BusinessRequirements/Betrieb und Support.md b/docu/Concepts/BusinessRequirements/Betrieb und Support.md new file mode 100644 index 000000000..b5ebabd49 --- /dev/null +++ b/docu/Concepts/BusinessRequirements/Betrieb und Support.md @@ -0,0 +1,137 @@ +# Betrieb und Support + +Dieses Dokument beschreibt die Anforderungen für den Betrieb und Support der Gradido-Anwendung während der Entwicklungsphase. Diese gelten nicht in vollem Umfang für den Betrieb der Gradido-Anwendung für eine neue Community, die sich rein auf eine Produktiv-Umgebung reduzieren läßt. + +# Umgebungen + +Für die Phase der Entwicklung werden folgende Stages benötigt: + +* LOKAL-Stage: Entwicklungsumgebung für einen Entwickler +* DEV-Stage: zentrale Entwicklungsumgebung für erste Integrationsschritte aus dem Entwicklerteam +* INT-Stage: zentrale, produktionsnahe Integrationsumgebung zum Aufbau und Test eines neuen Release +* PROD-Stage: zentrale Produktiv-Umgebung für den Betrieb mindestens einer Community + + +## LOKAL-Stage + +Die lokale Entwicklungsumgebung liegt in dem Verantwortungsbereich eines jeden Entwicklers. Es müssen dabei für die Entwicklung im Gradido-Team alle notwendigen Tools und Komponenten installiert bzw. vorhanden sein. + +### Resources + +### Betriebesystem + +### Tools + +### Komponenten und Dienste + + + +## DEV-Stage + + +### Resources + +CPU + +RAM + +Storage + +Network/Traffic + +Backup + +### Betriebesystem + +### Tools + +### Komponenten und Dienste + + +## INT-Stage + + +### Resources + +CPU + +RAM + +Storage + +Network/Traffic + +Backup + +### Betriebesystem + +### Tools + +### Komponenten und Dienste + + +## PROD-Stage + + +### Resources + +CPU + +RAM + +Storage + +Network/Traffic + +Backup + + +### Betriebesystem + +### Tools + +### Komponenten und Dienste + +#### Security + +#### Backup und Restore + +tägliches Backup + +#### Redundanz und Failover + +Virtulisierung + +Balancing + + + +# Provider + +Für das Hosting der Stages DEV, INT, PROD wird ein Provider gesucht, der die gewünschten Anforderungen als Dienstleister zu einem angemessenen Preis und mit seriösem Hintergrund anbietet. Es sollen hier verschiedenen Provider aufgelistet und ihre Leistungen und Kosten gegenübergestellt werden, so dass eine Entscheidungsfindung für eine Beauftragung möglich wird. + +## aktuell beauftragte Provider und Dienstleister + +Derzeit (10.2021) sind Leistungen und Dienste von folgenden Providern gebucht: + +### Elopage + +Forum, Mitglieder-Pakete, Spenden + +### Klicktipp + +Newsletter + +### ebiz + +Marktplatz + +### 1fire + +Webhoster PROD + +ohne Backup + +### strato + +Webhoster DEV und INT diff --git a/docu/Concepts/BusinessRequirements/CommunityVerwaltung.md b/docu/Concepts/BusinessRequirements/CommunityVerwaltung.md index 5e61860eb..8e86c76ef 100644 --- a/docu/Concepts/BusinessRequirements/CommunityVerwaltung.md +++ b/docu/Concepts/BusinessRequirements/CommunityVerwaltung.md @@ -4,66 +4,119 @@ Diese Konzept beschreibt den Begriff "Community" im Kontext von Gradido, welche ## Die Bedeutung des Begriffs Community -Eine Community bedeutet im Kontext von Gradido eine Gemeinschaft von Personen, die sich nach der Philosophie von Gradido zu einer gemeinsamen Gruppierung zusammenschließen. Unter dem gemeinsamen Zusammenschluß folgen sie der Natürlichen Ökonomie des Lebens. Die Community dient dabei als Rahmen für die Gruppe von Personen, um ihnen den geregelten Zugang zu ermöglichen. Unter dem Begriff "Zugang zur Community" wird die Registrierung eines Benutzerkontos für eine Person verstanden. Dabei erfolgt eine Autentifizierung der Person, um einen personenspezifischen Zugriff auf die Community-Funktionalitäten zu ermöglichen. Denn eine Community bietet einer Person eine Vielzahl an Funktionalitäten, die ein Community-Mitglied nutzen kann. So steht die Verwaltung und das Handeln mit Gradido-Geld als die Hauptfunktionalität einer Community im Vordergrund. Doch sind auch weitere Funktionalitäten, wie eine Selbstdarstellung über Benutzerprofile oder ein sich Vernetzen mit Community-Mitgliedern, aber auch ein Community übergreifendes Vernetzen als soziale Netzewerke möglich. So können aus kleinen Communities über Vertrauensverhältnisse Zusammenschlüsse mehrere eigenständigen Communities entstehen oder auch eine Hierarchie von Communities als Parent-Child-Verbindung aufgebaut werden (siehe weiter unten "Community-Modelle"). +Eine Community bedeutet im Kontext von Gradido eine Gemeinschaft von Personen, die sich nach der Philosophie von Gradido zu einer gemeinsamen Gruppierung zusammenschließen. Unter dem gemeinsamen Zusammenschluß folgen sie also einerseits gemäß der Gradido-Philosophie der *Natürlichen Ökonomie des Lebens* und andererseits ihrer ursprünglichen Idee eine Gemeinschaft zu bilden. -Innerhalb der Community erfolgt die Umsetzung und Verwaltung des "lebendigen Geldes". Soll heißen hier werden die Mechanismen zur Dreifachen-Schöpfung vollzogen, die das geschöpfte Geld nach den Community-Regeln auf die drei Arten von Empfängerkonten (Benutzerkonto, Gemeinwohlkonto und Ausgleichs- und Umweltkonto) verteilt. Ein Community-Mitglied kann über seinen Community-Zugang auf sein persönliches Benutzerkonto zugreifen und darüber sein Gradido-Geld verwalten. Neben der Einsicht auf seinen aktuellen Kontostand kann er u.a. seine regelmäßig geschöpften Gradido einsehen, mit vorhandenen Gradido bezahlen oder einem anderen Mitglied Gradido überweisen. Die Geldbewegungen werden als eine Liste von Transaktionen geführt und die Vergänglichkeit der Gradidos immer aktuell zur Anzeige gebracht. +Als Gradido System-Komponente beinhaltet die *Community* die grundlegenden Funktionalitäten und Prozesse zur Verwaltung der Gruppenmitglieder, ihrer Registrierungs- und Systemzugriffe, die Konten- und Geldverwaltung einerseits und andererseits die Funktionalitäten und Prozesse zur Vernetzung und Kommunikation von mehreren Communities untereinander . + +Innerhalb der Community-Komponente erfolgt die Umsetzung und Verwaltung des *lebendigen Geldes*. Soll heißen hier werden die Mechanismen zur Dreifachen-Schöpfung vollzogen, die das geschöpfte Geld nach den Community-Regeln auf die drei Arten von Empfängerkonten (AktivesGrundeinkommenkonto, Gemeinwohlkonto und Ausgleichs- und Umweltkonto) verteilt. Ein Community-Mitglied kann über seinen Community-Zugang auf sein persönliches Benutzerkonto zugreifen und darüber sein Gradido-Geld verwalten. Neben der Einsicht auf seinen aktuellen Kontostand kann er u.a. seine regelmäßig geschöpften Gradido einsehen, mit vorhandenen Gradido bezahlen oder einem anderen Mitglied Gradido überweisen. Die Geldbewegungen werden als eine Liste von Transaktionen geführt und die Vergänglichkeit der Gradidos immer aktuell zur Anzeige gebracht. Nach der Bedeutung des Begriffs Community werden nun die Eigenschaften einer Community detailliert beschrieben, damit all die zuvor erwähnten Möglichkeiten der Community abbildbar sind. ## Eigenschaften einer Community -Hier werden die Eigenschaften einer Community beschrieben, die notwendig sind, um die oben erwähnten Möglichkeiten der Community zu erfüllen. Es geht dabei um verschiedene Themen und ihre dazu notwendigen Prozesse, die wiederum unter Verweiß in anderen Dokumenten detailter beschrieben sind. +Hier werden die Eigenschaften einer Community beschrieben, die notwendig sind, um die oben erwähnten Möglichkeiten der Komponente zu erfüllen. Es geht dabei um verschiedene Themen und ihre dazu notwendigen Prozesse, die wiederum unter Verweiß in anderen Dokumenten detailter beschrieben sind. + +### Währung + +In einer Community werden die Prozesse der 3-fachen-Geldschöpfung, sowie der Transfer von Geld in der *Gradido-Währung* ablaufen. Mit dem Erstellen einer neuen Community wird technisch gesehen gleichzeitig auch eine eigene *Community-Gradido* Währung bei der Schöpfung erzeugt. + +Ziel dieser Community eigenen Währung ist für die Gemeinschaft über ein Währungs-Branding sich marketingstechnisch hervorheben zu können. Zum Beispiel könnte eine Community aus der Region "Liebliches Taubertal" sich über den *Community-Gradido* den sogenannten "Taubertäler" erzeugen, den die Mitglieder dann aber auch überregional mit anderen Communities in Umlauf bringen und somit Werbung für ihre Region machen. + +| PR-Kommentare | | +| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Was hälst du von einem Namen für die Währung "Der Taubertäler", den jede Community definieren kann, sich aber auch zu einer anderen anschließen kann. Dies ist aber nur das Branding in Sachen Anzeige & Marketing. Darunter liegt der Gradido - dieser ist weiter aufgestellt als nur regional - nämlich weltweit. Auch hier müssen "Bösewichte" ausgeschlossen werden können - Prozess & Regeln dafür?

Ich mache mir einfach ein wenig Sorgen, dass wir die Anforderung "Jeder Coin hat eine eindeutige Community-Prägung" nicht erfüllen können mit der aktuellen Implementierung und ich habe auch Schwierigkeiten mir vorzustellen, wie sich das mit Schwundgeld verhalten soll - insbesondere mit stärker schwindendem Geld bei größerer Geldmenge. Der Schwund ist also auf alle meine Coins gebunden, währen die Prägung auf den jeweiligen Coin passiert. Ich glaube das ist sehr schwierig beides entsprechend abzubilden. | +| Claus-Peter 25.11.2021 | Ich kann die Bedenken einerseits verstehen und andererseits die Visionen von Bernd nachvollziehen. Dass diese nicht immer einfach unter einen Hut zu bringen sind, ist klar und dennoch möchte ich diese zumindest in den fachlichen Anforderungen nicht einfach rausstreichen.
Wie diese dann technisch zu konzipieren sind ist und bleibt letztendlich genau unsere Aufgabe. | + +Andererseits soll aber, wenn eine Community sich bei der Geldschöpfung nicht an die Regel der *Gradido-Philosopie* hält, eine technische Möglichkeit geschaffen sein, dass diese Community in ihrer weiteren Geldschöpfung und dem Handel *ihrer* Währung sanktioniert werden kann. + +Aber grundsätzlich bleibt bei allen *Community-Gradido*-Währungen die Vergänglichkeit als Sicherungsmechanismus des Geldvolumens und der 1:1 Umtausch zwischen verschiedenen *Community-Gradidos* bestehen. + +#### Schutz vor Falschgeld + +- Blacklisting +- Bereinigung durch Bezahlen nach Priorisierung + - 1. GDD von der Community des Empfängers + 2. GDD von anderen Communities nach Menge von wenig nach viel + 3. GDD von der eigenen Community + 4. geblacklistete werden gar nicht verwendet und vergehen + +* Vergänglichkeitsbereinigung + * 1. GDD anderer Communities nach Menge von wenig nach viel + + +| PR-Kommentare | | +| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Wenn die geblacklisteten Coins prioritisiert vergehen kann der findige Angreifer den Verfall umgehen, indem er sich ungültige/blacklistete Coins erschafft, die dann genau seinem Verfall entsprechen. | +| Claus-Peter 25.11.2021 | Das Kapitel "Schutz vor Falschgeld" ist wohl eher noch im Status "Brainstorming" zu verstehen. Hier wurden mögliche Regeln notiert, die noch nicht in ihrer Gänze durchdacht und konzipiert sind.
Der Punkt Vergänglichkeitsbereinigung sagt folgendes aus:
Kontostand am 01.01.2021:
- 100 GDD aus der eigenen Community
- 100 GDD aus Community A
- 100 GDD aus Community B
- gesamt 300 GDD

Nach einem Jahr ohne irgendwelche weiteren Transaktionen ergibt sich folgendes am 31.12.2021:
- Vergänglichkeit mit 365 Tagen bei 300 GDD = 150 GDD (nicht gerechnet, sondern 50%)
- die 150 GDD Vergänglichkeit als Tx-Buchung führt zu folgendem Kontostand:
* 100 GDD aus der eigenen Community
* 50 GDD aus der Community A
* 0 GDD aus der Community B
* gesamt 150 GDD

Soweit der Gedankengang zur Bereinigung des Kontos mit GDD aus anderen Communities. Das hat keine Auswirkung auf die Wertigkeit, sondern soll sich allein auf die Reduktion der Viefältigkeit an Community-Währungen im eigenen Konto führen. | + + +* Bezahl-Vorbereitung + * Austausch von Blacklist zw. Teilnehmer + * ggf. Übersteuern der Balcklist falls gewünscht + +| PR-Kommentare | | +| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Ich denke die vervielfachung von Coins und damit eine Ab/Auf-Wertung der jeweiligen Währen einer Community ist entgegen dem Konzept von Gradido. Gradido schafft eine stabile Zeit-Tausch-Einheit. Diese sollte Weltweit den gleichen Wert haben - warum sollte der Peruaner für seine Zeit weniger Gradido bekommen als ein Europäer? Das zementiert einfach weiterhin die bestehende Ordnung auf dem Planeten. Wollen wir das?
Daher mein Credo: Niemals einen Faktor zwischen Communities einführen. | +| Claus-Peter 25.11.2021 | Den Kommentar verstehe ich nicht in Bezug auf die zitierten Dokument-Zeilen.
Wo finden sich Hinweise auf eine Ab/Auf-Wertung der Währung?
Das Blacklisting ist mit Sicherheit ein sehr sensibler Punkt und muss genauestens und tiefer durchdacht und konzipiert werden.
Ansonsten stimme ich dem Inhalt und deinem Credo voll zu. | + ### Anzeige und -Darstellung -Da es also mehrere Communities geben wird, benötigt jede Community ihren eigenen Namen und gar ein Symbol oder Bild, um eine optische Unterscheidung bei der Anzeige in den Systemen sicherzustellen. Für eine Aussendarstellung wäre eine Beschreibung der Community und ihre eigene Philosopie, was die Community auszeichnet hilfreich. Diese Werte müssen vom Community-Administrator gepflegt werden können. +Da es also mehrere Communities geben wird, benötigt jede Community ihren eigenen Namen und gar ein Symbol oder Bild, um eine optische Unterscheidung oder gar eigenes Branding bei der Anzeige in den Systemen sicherzustellen. Für eine Aussendarstellung wäre eine Beschreibung der Community und ihre eigene Philosopie, was die Community auszeichnet hilfreich. Diese Werte müssen vom Community-Administrator gepflegt werden können. ### Mitgliederverwaltung -Für die Verwaltung von Community-Mitgliedern werden entsprechende Verwaltungsprozesse wie Registrierung, Login mit Autentifizierung, eine Benutzerverwaltung für neue, bestehende und ausscheidende Mitgleider benötigt. Die Benutzerverwaltung stellt zusätzlich die Anforderung, dass ein Community-Mitglied eindeutig identifizierbar ist und das Community übergreifend. Das bedeutet es kann eine Person immer nur einmal existieren und darf auch niemals in mehreren Communities gleichzeitig Mitglied sein. Denn es muss sichergestellt werden, dass eine Person sich keine unerlaubte Vorteil durch zum Beispiel mehrfache Geldschöpfung in mehreren Communities verschafft. Die Details der Mitgliederverwaltung werden beschrieben im Dokument [BenutzerVerwaltung](.\BenutzerVerwaltung.md). +Für die Verwaltung von Community-Mitgliedern werden entsprechende Verwaltungsprozesse wie Registrierung, Login mit Autentifizierung, eine Benutzerverwaltung für neue, bestehende und ausscheidende Mitgleider benötigt. Die Benutzerverwaltung stellt zusätzlich die Anforderung, dass ein Community-Mitglied eindeutig identifizierbar ist und das Community übergreifend. Das bedeutet es kann eine Person immer nur einmal existieren und darf auch niemals in mehreren Communities gleichzeitig Mitglied sein. Denn es muss sichergestellt werden, dass eine Person sich keine unerlaubte Vorteile durch zum Beispiel mehrfache Geldschöpfung in mehreren Communities verschafft. -### Community-Vernetzung +Die Details der Mitgliederverwaltung werden beschrieben im Dokument [BenutzerVerwaltung](.\BenutzerVerwaltung.md). -Für die Community-Vernetzung sind Verwaltungsprozesse zwischen den Communities und auch den Community-Mitgliedern notwendig, um entsprechende Vertrauensverhältnisse aufzubauen. Diese müssen den notwendigen Sicherheitsansprüchen genügen, da darauf aufbauend dann später die Geld-Flüsse abgewickelt werden. Entsprechend den Community-Modellen (siehe im folgenden Unterkapitel **Community Modelle**) wird ein Prozess benötigt, der die Hierarchie bzw. das Vertrauensverhältnis zwischen zwei eigenständigen Communities aufbaut und daraus dann die möglichen Funktionalitätserweiterungen für die Mitglieder bzw. den Communities freischaltet bzw. unterstützt. Zusätzlich wird auch der jeweilige umgekehrte Prozess benötigt, der eine bestehende Hierarchie bzw. ein bestehendes Vertrauensverhältnis zwischen zwei Communities auflöst und löscht, sowie die daraus resultierenden Funktionseinschränkungen für die Mitglieder und die betroffenen Communities. +### Community-Netzwerk -Zum besseren Verständnis der Community-Vernetzung erfolgt hier eine Beschreibung der möglichen Konstellationen, wie sich Communities miteinander verbinden können. +Ein grundlegender Ansatz des Gradido-Systems beinhaltet die Einstufung aller beteiligten Gradido-Communities als gleichberechtigte Einheiten. Diese bilden unterneinander ein Kommunikations-Netzwerk zum Austausch an Informationen, aber auch zum Aufbau eines gemeinsamen Verbundes weiterer Aktivitäten. -#### Community Modelle +#### Vernetzung -Bei Gradido werden verschiedene Modelle von Community-Abhängigkeiten unterstützt. Dabei soll unterschieden werden zwischen: +Die Vernetzung der Gradido-Communities erfolgt automatisch über eine Channel-Infrastruktur. -* eigenständige Community -* sich gegenseitig vertrauende Communities -* von einander abhängige (vererbende) Communities -* Mischung aus den vorherigen Modellen +![CommunityCreationChannel](./image/CommunityCreationChannel.png) -Das nachfolgende Bild zeigt einen ersten Eindruck über die unterschiedlichen Community-Modelle: +Das bedeutet mit dem Aufsetzen und Inbetriebnehmen einer neuen Community erfolgt eine automatisierte Vernetzung der neuen Community mit den schon existierenden Communities über einen dedizierten Kommunikationskanal. Dies dient in aller erster Linie dazu, dass sich alle Gradido-Communities untereinander kennen lernen. Das dadurch entstehende Netzwerk von Gradido-Communities benötigt somit keinen zentralen Knoten, der die Verwaltung der dem Netzwerk beigetretenen Instanzen übernehmen müsste. -![CommunityModell](./image/CommunityModell.png) +![CommunityNetwork](./image/CommunityNetwork.png) -##### Eigenständige Community +Alle späteren Aktivitäten wie u.a. das gemeinsame Handeln oder Gradido-Transfer erfolgen dann in direkter Kommunikation zwischen zwei Communities. Dabei lauschen die Communities an nach fachlichen Themen separierte Kommunikationskanäle. Sobald eine direkt an eine Community adressierte oder auch wenn eine für eine Community interessante Nachricht empfangen wird, erfolgt die weitere Verarbeitung dieser Nachricht in direktem Austausch der beiden betroffenen Communities. Durch die Teilnahme einer Community an spezifischen fachlichen Kommunikationskanäle lernen sich die Communities untereinander an ihren spezifischen Interessen besser kennen bzw. können auch durch aktives Propagieren die engere Vernetzung zwischen den Communities beschleunigen. -Eine eigenständige Community zeichnet sich darin aus, dass sie keine Beziehung zu einer anderen Community aufgebaut hat. Das heißt sie hat weder eine vertrauenswürdige Verknüpfung mit einer zweiten Community, noch hat sie eine Verbindung zu einer Parent-Community und besitzt auch selbst keine Verbindung zu einer Child-Community. Somit kann diese Community für ihre Mitglieder nur Community intern wirksame Prozesse anbieten. Das heißt es ist kein Community übergreifender Handel bzw. Austausch von Gradido möglich. Andererseits werden in dieser Community die Prozesse freigeschaltet, dass ein Aufbau eines vertrauenswürdiges Verhältnis zu einer anderen Community erlaubt, der Aufbau einer Parent-Beziehung und auch der Aufbau einer Child-Beziehung ermöglicht. Die zugehörigen Abbau-Prozesse dagegen sind nicht freigeschalten. Der Community übegreifende Überprüfungsprozess bei der Mitglieder-Registrierung zur eindeutigen Identifikation in der Mitglieder-Verwaltung zählt dabei nicht als vertrauenswürdige Verbindung zwischen Communities. +![CommunityChannelCommunication](./image/CommunityChannelCommunication.png) -##### Gegenseitig vertrauende Communities +#### Ausfallsicherheit -*Hier soll beschrieben werden, was den Unterschied auszeichnet zu einer "Eigenständigen Community", wie man das gegenseitige Vertrauen (sprich Verknüpfung) zwischen zwei oder mehreren Communities auf- und wieder abbaut, was bedarf es an Vorraussetzungen für einen Vertrauens-Auf/Abbau und welche Konsequenzen der Auf- und Abbau des gegenseitigen Vertrauens haben soll.* +Ein weiterer wichtiger Aspekt der Community-Vernetzung ist die Sicherstellung der Ausfallsicherheit. Dabei erfolgt im Community-Netzwerk die Verteilung von Community eigenen Daten auf Knoten anderer Communities. Dadurch kann jederzeit bei einem Ausfall eines Netzwerkknotens und den damit betroffenen Communities einerseits ein online Fail-Over-Szenario betrieben werden und/oder andererseits der Wiederaufbau eines neuen Knotens mit den verlorenen Community-Daten und aus dem Netzwerk wiederhergestellten Daten erfolgen. -Das Modell der sich *gegenseitig vertrauenden Communities* entspringt der Idee des sich miteinander Vernetzens und damit das Handeln und Agieren mit Gradido-Mitgliedern, die nicht in der eigenen Community als Mitglied registriert sind. Um dies zu ermöglichen bedarf es einem Aufbau-Prozess zwischen zwei Communities, die sich zukünftig gegenseitig ein enges Vertrauen schenken. Auf der Basis dieses Vertrauens tauschen die beiden Communities Informationen untereinander aus, so dass für die Mitglieder beider Communities die Funktionalitäten auf der Gradido-Plattform so transparent erscheinen, als ob sie alle Mitglied einer Community wären. Das würde sich beispielsweise bei der Suche nach einem bestimmten Community-Mitglied auswirken, da nun alle Mitgleider beider Communities in einer Liste zur Anzeige gebracht werden können. Oder der Transfer von Gradidos von einem Mitglied zu einem anderen Mitglied ist über dieses Community-Verhältnis nun auch Community übergreifend möglich. Auch weitere Angebote, die bisher nur in einer Community zur Verfügung standen, sind nun auch den Mitgliedern der anderen Community zugänglich. +#### Eindeutige Mitgliedschaft -Während des Aufbau-Prozesses werden neben den eigentlichen Security relevanten Informationen für den Aufbau und die Sicherstellung des Vertrauensverhältnisses auch fachliche Informationen ausgetauscht. Unter fachlichen Informationen sind die nun freigeschaltenen Angebote beider Communities gemeint. Somit werden in der einen Community nun auch die fachlichen Prozesse und Angebote der anderen Community zugänglich und freigeschalten und umgekehrt. Wie feingranular die Prozesse und Angebote dabei ausgetauscht und freigeschaltet werden unterliegt einer administrativen Konfiguration der jeweiligen Community. Das heißt der Administrator jeder Community kann im Vorfeld selektiv konfigurieren welche Angebote und Prozesse beim Aufbau-Prozess für ein Vertrauensverhältnis mit einer anderen Community übertragen und freigeschaltet werden. Diese Konfiguration sollte zuvor Community intern abgestimmt sein, um nicht schon zu Beginn der Zusammenarbeit der beiden Communities irgendwelche Missstimmungen unter den Mitgliedern zu verursachen. Die Details des *Vertrauensverhältnis Aufbau-Prozesses* sind weiter unten im Kapitel **Anwendungsfälle** beschrieben. +Durch das Community-Netzwerk erfolgt auch der sehr wichtige Prozess der Sicherstellung, dass eine natürliche Person sich nur einmal bei einer Community im gesamten Community-Netzwerk registrieren darf. Dazu erfolgt ein Informationsaustausch über einen bestimmten Kommunikationskanal zwischen allen Communities untereinander. Das dazu notwendige Protokoll und die benötigten Daten werden im technischen Konzept definiert. Die Entscheidung, ob die Überprüfung der eindeutigen Mitgliedschaft direkt mit dem eigentlichen Registrierungsprozess eines Mitglieds gekoppelt werden kann oder ob diese nachträglich asynchron im Hintergrund stattfinden muss, findet erst bei der technischen Konzeption ggf. durch ein technisches Proof-of-Concept statt. -##### Abhängige Communities +| PR-Kommentar | | +| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Diese Anforderung ist technisch nicht zu erfüllen.
1. Eine Identifikation einer Person erfolgt immer mithilfe eines technischem Identifiers wie z.B. der Personalausweisnummer, EMail, Telefonnummer oder anderes. Schon durch diese Abstraktion kann ein Nutzer mehr als eine Identität aufbauen (2 Telefonnummer z.B.)
2. Die Prüfung auf Eindeutigkeit in einem dezentralen Netzwerk kann nicht sichergestellt werden, da Teile des Netzwerks zum Zeitpunkt der Prüfung nicht erreichbar oder gar unbekannt sein können.
3. Bedarf es den Austausch der Personen-Identifikation zwischen dem Communties: "kennst du email@domain.com?". Diese Daten können verschlüsselt werden z.B mit `hash(salt,email)` welche dann an jede Community geschickt werden: kennst du `hash(salt,email), salt`? Was dazu führt, dass jede Community den hash aller seiner EMails errechen muss - die Skalierung ist entsprechend schlecht.

Alternativ kann hier eine Blockchain eingesetzt werden, welche `hash(salt,email), salt` speichert und als dezentrales Nachschlagewerk für alle zugänglich ist. Hier erwarte ich ein Konzept, bevor wir das umsetzen können. Die Sicherheit der Nutzerdaten ist ebenfalls genau zu untersuchen, wenn wir das ganze ins Internet blasen. | +| Claus-Peter 25.11.2021 | Ja da gebe ich dir nach heutigem Stand vollkommen Recht, dass es dafür derzeit keine 100% technische Lösung gibt.
Trotzdem ist das Thema fachlich gewünscht und wir müssen uns Gedanken machen, wie wir dafür eine technische Lösung finden können, die nahezu an die Anforderungen heranreicht. Genau deshalb endet dieser Absatz mit dem Hinweis auf die technsiche Konzeption. | -*Hier soll beschrieben werden, was den Unterschied zu eigenständigen und sich gegenseitig vertrauenden Communities zu den hier abhängigen (sprich vererbten) Communities auszeichnet, welche Vorraussetzungen bedarf der Auf/Abbau einer abhängigen Community und welche Konsequenzen hat der Auf- und Abbau von abhängigen Communities.* -Das Modell der *abhängigen Communities* findet seinen Ursprung den Föderalismus von Deutschland in einer Community-Struktur abbilden zu können. Das bedeutet, dass eine baumartige Struktur von Communities aufgebaut werden kann, wie nachfolgendes Bild schemenhaft zeigt: +### Hirarchische Community + +Um die Vision Gradido als Währung nicht nur in Communities als gemeinsame Interessensgemeinschaften zu etablieren, sondern auch für ganze Communen, Bundesländer, Nationen oder gar weltweit, bedarf es einer Strukturierung von Communities. Dazu dient das Konzept der *hierarchischen Community*, seinen Ursprung in der Abbildung des Föderalismus von Deutschland findet. Das bedeutet, dass eine baumartige Struktur von Communities aufgebaut werden kann, wie nachfolgendes Bild schemenhaft zeigt: + +| PR-Kommentar | | +| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 25.11.2021 | Ich denke Förderalismus wie in der Bundesrepublik ist mit Gradido nicht möglich. Es ergibt sich durch das Schwundgeld einfach keine Vorteile eines Förderalismus.
Szenario Straßenbau zwischen zwei Communties:
- Warum sollte Geld von beiden Communities auf ein drittes Konto fließen, wenn es dort doch nur vergeht?
- Ist es nicht realistischer, dass beide Communties sich auf den Straßenbau einigen und das Geld direkt an den Auftragnehmer überweisen, um dem Schwund so weit es geht zu entgehen.

Warum sollte sich eine Community einer anderen unterordnen? Was sind die Vorteile?
*Nur ein Gedanke* | +| Claus-Peter 25.11.2021 | Ich kann deinen Gedanken und Bedenken folgen, doch andererseits kann ich auch dem Föderalismus etwas abgewinnen.
Klar würde sich eine Community schwer tun, sich einer anderen Community unterzuordnen. Doch genau da beginnt die Überlegung, wie man ein Community-übergreifendes Projekt organisieren könnte? Da gibt es schon Vorteile, die natürlich noch feiner konzipiert und ausformuliert werden müssen. Daher sollten wir die Hierarchie von Communities nicht im Vorhinein ausschließen. | + ![hierarchisches Community-Modell](./image/HierarchischesCommunityModell.png) -Es wird somit zwischen zwei Communities aus benachbarten Ebenen eine Parent-Child-Beziehung erzeugt. Dadurch gehen diese beiden Communities eine besondere Beziehung untereinander ein, die zu folgenden veränderten Eigenschaften und Verhalten der Parent- und der Child-Community führen: +Es wird somit zwischen zwei Communities aus direkt benachbarten Ebenen eine Parent-Child-Beziehung erzeugt. Dadurch gehen diese beiden Communities eine besondere Beziehung untereinander ein, die zu folgenden veränderten Eigenschaften und Verhalten der Parent- und der Child-Community führen: -###### Parent-Community +#### Parent-Community * kann 1 bis n Child-Communities besitzen * verwaltet keine Mitglieder mit AGE-Konto @@ -73,14 +126,14 @@ Es wird somit zwischen zwei Communities aus benachbarten Ebenen eine Parent-Chil * bedarf spezieller Administrationsprozesse zur Verwaltung der Parent-Aufgaben: * Auf- und Abbau der Parent-Child-Beziehung * Verschiebung aller Mitglieder von der Parent- in die Child-Community - * Stoppen des Sicherstellungsprozesses, dass eine *natürliche Person* nur Mitglied einer einzigen Community ist, sobald die erste Child-Beziehung aufgebaut ist und alle Mitglieder dahin verschoben sind + * Stoppen des Sicherstellungsprozesses, dass eine *natürliche Person* nur Mitglied einer einzigen Community ist, sobald die erste Child-Beziehung aufgebaut ist und alle Mitglieder dorthin verschoben sind * Prozess zur Aufnahme der geschöpften Allgemeinwohl- und AUF-Gelder aus den Child-Communities * stoppt den Schöpfungsprozess sobald eine Child-Beziehung aufgebaut ist * startet den Schöpfungsprozess sobald die letzte Child-Beziehung aufgelöst ist * Aufnahmeprozess von Mitgliedern aus einer Child-Community, bevor dessen Beziehung aufgelöst wird * starten des Sicherstellungsprozesses, dass eine *natürliche Person* nur Mitglied einer einzigen Community ist, sobald die letzte Child-Beziehung aufgelöst ist -###### Child-Community +#### Child-Community * besitzt genau eine Parent-Community * **sofern es eine Community der untersten Ebene ist:** @@ -94,32 +147,38 @@ Es wird somit zwischen zwei Communities aus benachbarten Ebenen eine Parent-Chil * hier läuft der Prozess zur Sicherstellung, dass eine *natürliche Person* nur Mitglied einer einzigen (Child)-Community ist * - - - - - - -##### Mischung aus den vorherigen Modellen - -*Hier soll beschrieben werden welche möglichen Mischungen von Modellen erlaubt sind und welche nicht, was hat eine Mischungsvariante an Konsequenzen, wie wird eine Mischungsvariante auf/abgebaut, welche Vorraussetzungen bedarf es für den Auf/Abbau einer Mischungsvariante.** - ### Geldschöpfung -Eine Community stellt die Mechanismen für die Dreifache-Geldschöpfung bereit. Dazu müssen zuerst die Verteilungsschlüssel auf die drei Kontoarten definiert bzw. konfigurierbar sein. Diese Konfigurationswerte werden vom Community-Administrator gepflegt. Sie dienen als Grundlage für die Höhe der regelmäßig geschöpften Beträge auf die drei Empfängerkonto-Typen. Die regelmäßige Geldschöpfung läuft automatisiert im Hintergrund und muss den Regeln der Nartürlichen Ökonomie des Lebens folgen. Die Details der Dreifachen Geldschöpfung sind in dem Dokument [RegelnDerGeldschoepfung](./RegelnDerGeldschoepfung.md) beschrieben. +Eine Community stellt die Mechanismen für die Dreifache-Geldschöpfung bereit. Dazu müssen zuerst die Verteilungsschlüssel auf die drei Kontoarten definiert bzw. konfigurierbar sein. Diese Konfigurationswerte werden vom Community-Administrator gepflegt. Sie dienen als Grundlage für die Höhe der regelmäßig geschöpften Beträge auf die drei Empfängerkonto-Typen. Die regelmäßige Geldschöpfung läuft teilweise automatisiert im Hintergrund und muss den Regeln der Nartürlichen Ökonomie des Lebens folgen. Die Details der Dreifachen Geldschöpfung sind in dem Dokument [RegelnDerGeldschoepfung](./RegelnDerGeldschoepfung.md) beschrieben. ### Konto-Verwaltung -Durch die Dreifach-Geldschöpfung verwaltet die Community auch die drei Arten von Konten: Benutzerkonto, Gemeinwohlkonto und Ausgleichs- und Umweltkonto(AUF). +Für die Dreifach-Geldschöpfung verwaltet die Community drei Arten von Konten: das AktiveGrundeinkommen-Konto pro Mitglied, das Community-eigene Gemeinwohlkonto und das Community-eigene Ausgleichs- und Umweltkonto(AUF). -Für jedes Mitglied der Community wird also ein eigenes Benutzerkonto verwaltet, auf das ein Drittel der monatlichen Geldschöpfung fließt. Das Gemeinwohlkonto und das AUF-Konto existieren pro Community einmal und auf jedes der beiden Konten fließen monatlich die beiden anderen Drittel der Geldschöpfung. +Für jedes Mitglied der Community wird also ein eigenes AktiveGrundeinkommen-Konto verwaltet, auf das ein Drittel der monatlichen Geldschöpfung unter Einhaltung der AGE-Regeln fließt. Das Gemeinwohlkonto und das AUF-Konto existieren pro Community einmal und auf jedes der beiden Konten fließen monatlich die beiden anderen Drittel der Geldschöpfung. -Somit muss also eine Community für jede Kontoart die entsprechenden Kontoverwaltungsprozesse anbieten. Einmal in Verbindung pro Mitglied für das Benutzerkonto und dann jeweils eine Verwaltung für das Gemeinwohlkonto und eine Verwaltung für das AUF-Konto. Die Berechtigungen für die Zugriffe auf die drei Kontoarten müssen ebenfalls in der Community gepflegt und kontrolliert werden. Das bedeutet die Community muss ihren Mitgliedern auf ihre eigenen Benutzerkonten Zugriffsrechte erteilen und diese auch kontrollieren, so dass keine unerlaubten Zugriffe stattfinden können. Dann müssen in der Community bestimmte Mitglieder Sonderberechtigungen erhalten, um die Verwaltung des Gemeinwohlkontos und des AUF-Kontos durchführen zu können. Die Verwaltung der Berechtigungen ist wiederum alleine dem Community-Administrator erlaubt. Die Details der Kontenverwaltung ist im Dokument [KontenVerwaltung](.\KontenVerwaltung.md) beschrieben. +Somit muss also eine Community für jede Kontoart die entsprechenden Kontoverwaltungsprozesse anbieten. Einmal in Verbindung pro Mitglied für das AGE-Konto und dann jeweils eine Verwaltung für das Gemeinwohlkonto und eine Verwaltung für das AUF-Konto. Die Berechtigungen für die Zugriffe auf die drei Kontoarten müssen ebenfalls in der Community gepflegt und kontrolliert werden. Das bedeutet die Community muss ihren Mitgliedern auf ihre eigenen AGE-Konten Zugriffsrechte erteilen und diese auch kontrollieren, so dass keine unerlaubten Zugriffe stattfinden können. Dann müssen in der Community bestimmte Mitglieder Sonderberechtigungen erhalten, um die Verwaltung des Gemeinwohlkontos und des AUF-Kontos durchführen zu können. Die Verwaltung der Berechtigungen ist wiederum alleine dem Community-Administrator erlaubt. Die Details der Kontenverwaltung ist im Dokument [KontenVerwaltung](.\KontenVerwaltung.md) beschrieben. + +### Tätigkeitsverwaltung + +Hier handelt es sich um eine Verwaltung von Tätigkeitsbeschreibungen, die von den Community-Mitgliedern als akzeptierte und berechtigte Leistungen zur Geldschöpfung als *Aktives Grundeinkommen* angesehen werden. Das heißt die Community muss unter den Mitgliedern eine Liste erarbeiten, die alle Tätigkeiten enthält, aus denen sich ein Mitglied dann eine oder mehrere auswählen kann, um sich sein Aktives Grundeinkommen damit zu decken. Die einzelnen Tätigkeiten sollen auch fachlich strukturierbar sein z.B. Kunst, Soziales, Gesundheit, Produktion, etc. . Die Menge und Definition der einzelnen Tätigkeiten und Strukturen unterliegt einer stetigen Anpassung nach den Bedürfnissen der Community-Mitglieder, um den natürlichen Veränderungen des miteinander Lebens gerecht werden zu können. Ob zu einer Tätigkeitsbeschreibung auch gleich eine Wertigkeit definiert werden soll, ist noch offen. Man kann aber sicherlich sagen, dass manche Tätigkeiten dem Gemeinwohl dienlicher sind als andere. Aber auch das ist wiederum eine Ansichtsache und muss unter den Community-Mitgliedern vereinbart werden. + +| PR-Kommentar | | +| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Was ist wenn Tätigkeit A in Community X vergütet wird und Tätigkeit B in Community Y:
- Ich übe Tätigkeiten A & B aus
- Muss ich mich entscheiden, welche Tätigkeit ich vergütet wissen will? (Stichwort eindeutige Registrierung im gesammten Netzwerk) | +| Claus-Peter 25.11.2021 | Gute Frage!
Ich denke wir sollten im 1. Schritt damit beginnen, dass jede Community ihre eigene Aktivitätenliste pflegt. Es werden dann wohl gleiche Aktivitäten in mehreren Listen der verschiedenen Communities auftauchen.

Ich kann aber als Mitglied der Community A eine Tätigkeit A.X von einem Mitglied aus Community B bestätigt bekommen und natürlich auch von Mitgliedern aus meine Community A.

Dazu müssen dann natürlich die notwendigen Informationen zw. den Communities für eine Cross-Community-Bestätigung ausgetauscht werden. Das führt dann genau zu dem gewünschten Effekt, dass zw. zwei Communities ein Informationsaustausch stattfindet, der dann eine Aussage über den Cross-Handel und das Vertrauen ermöglicht. | + + +Zu der Liste der Tätigkeiten gibt es einen weiteren Prozess, der in dem Dokument [RegelnDerGeldschoepfung](./RegelnDerGeldschoepfung.md) näher beschrieben ist. Hier kann soviel erst einmal gesagt werden, dass die Tätigkeitenliste als Grundlage dient, damit ein Mitglied für seine erbrachten Leistungen für das Allgemeinwohl dann sein monatliches *Aktives Grundeinkommen* gutgeschrieben bekommt. Dieses Gutschreiben des AGEs unterliegt noch einer vorherigen Bestätigung von anderen Community- oder auch Community übergreifenden Mitgliedern. Somit erfolgt dadurch eine implizite Vernetzung der Mitglieder durch dieses aktive Bestätigen anderer Leistungen, was gleichzeitig wieder Vorraussetzung ist, um sein eigenes AGE zu erhalten. ### Berechtigungsverwaltung Die Community muss für die verschiedenen Eigenschaften und Prozesse eine eigene Berechtigungsverwaltung zur Verfügung stellen. Für die verschiedenen Berechtigungen muss ein Rollen- und Rechte-Konzept administrierbar sein, so dass für die verschiedenen Mitglieder der Community die Zugriffe feingranular definiert, gesteuert und kontrolliert werden können. Allein der Administrator hat die Rechte auf die Berechtigungsverwaltung zuzugreifen. Das System muss diese hinterlegten Rollen und Rechte dann auf die verwalteten Mitglieder abbilden und für jeden Zugriff auf die Community entsprechend kontrollieren, freigeben oder verhindern. +### Vernetzung und Vertrauensbildung + +Mit der Vernetzung der Communities und dem gemeinsamen Handel zwischen Community-Mitgliedern innerhalb des gesamten Netzwerks entsteht automatisch ein Vertrauensverhältnis zwischen den verschiedenen Communities und auch zwischen den Community-Mitgliedern. Diese sich dynamisch verändernde Vertrauensverhältnisse können als Graph aufbereitet und zu weiteren Auswertungen bzw. Priorisierungen von fachlichen Prozessen herangezogen werden. Da in dem Gradido-Netzwerk der Mensch und das gegenseitige Vertrauen im Mittelpunkt steht, benötigt er für seine Bewertungen und Entscheidungen von Handel und Austausch mit anderen Communities bzw. anderen Mitgliedern ein Werkzeug, das ihm diese Informationen liefern kann. Das bedeutet in der Gradido-Anwendung werden statistische Werte über die Kommunikation zwischen Communities und zwischen Mitgliedern erhoben, die als Grundlage für den Vertrauensgraphen dienen. + ### Attribute einer Community In diesem Kapitel werden die Attribute beschrieben, die in einer Community zu speichern sind. @@ -166,27 +225,39 @@ Das Attribut *Parent* dient für den hierarchischen Aufbau von Communities. Es e Das Attribut *Liste Children* dient ebenfalls dem hierarchischen Aufbau von Communities. Es enthält die Bezüge auf die Communities, die für diese Community als Child-Community eingerichtet sind. Eine Parent-Community kann mehrere Child-Communities haben. Durch diesen Bezug zu den Child-Communities werden einzelne Prozesse zwischen der Parent- und den Child-Communities freigeschalten. Damit ergeben sich erweiterte Möglichkeiten u.a. für die Community-Mitglieder beider Communities, wie beispielsweise das Community übergreifende Handeln zwischen den Community-Mitgliedern oder eine veränderte Verteiltung der Gemeinwohl- und AUF-Schöpfung, etc.. Die Administration dieses Attributes erfolgt implizit über die fachlichen Prozesse, die den Auf- und Abbau einer Parent-Child-Beziehung zwischen zwei Communities steuern. Diese können nur durch den Administrator und seiner Berechtigung ausgelöst werden. Die Beschreibung dieser Prozesse ist weiter unten im Kapitel **Anwendungsfälle auf einer Community** zu finden. -#### Liste Trusted Communities - -Das Attribut *Liste Trusted Communities* dient dem Aufbau von gleichberechtigten Community-Gruppierungen. Es enthält die Referenzen auf die Communities, die für diese Community als vertrauenswürdige Communities eingerichtet sind. Eine vertrauenswürdige Community-Gruppierung kann mehrere gleichberechtigte Communities haben. Durch diesen Bezug zu den vertrauenswürdigen Communities werden einzelne Prozesse zwischen den sich gegenseitig vertrauenden Communities freigeschalten. Damit ergeben sich erweiterte Möglichkeiten u.a. für die Community-Mitglieder beider Communities, wie beispielsweise das Community übergreifende Handeln zwischen den Community-Mitgliedern, etc.. Zwischen zwei *Trusted Communities* erfolgt keine Verteilung gemäß einem Verteilungsschlüssel von geschöpftem Geld das für das Allgemeinwohl- bzw. AUF-Konto bestimmt ist. Dies bleibt Eigentum jeder Community trotz vertrauenswürdiger Beziehung untereinander. - -Die Administration dieses Attributes erfolgt implizit über die fachlichen Prozesse, die den Auf- und Abbau einer vertrauenswürdigen Beziehung zwischen zwei Communities steuern. Diese können nur durch den Adminitrator und seiner Berechtigung ausgelöst werden. Die Beschreibung dieser Prozesse ist im nachfolgenden Kapitel **Anwendungsfälle auf einer Community** zu finden. - - ## Anwendungsfälle auf einer Community Die nachfolgenden Anwendungsfälle beschreiben die fachlichen Vorraussetzungen, den fachlichen Ablauf und die fachlichen Veränderungen bzw. den fachlichen Status, der am Ende des erfolgreich abgeschlossenen Anwendungsfalles erreicht wird. Desweiteren erfolgt die fachliche Beschreibung der möglichen Fehlerfälle, in die ein Anwendungsfall münden kann und welcher fachlicher Status am Ende des Anwendungsfalles herrschen soll. ### Neue Community erstellen -*Allgemeine fachliche Beschreibung des Anwendungsfalles.* +Der Prozess *Neue Community erstellen* kann in zwei grundlegende Schritte untergliedert werden. Im ersten Schritt erfolgt der Aufbau und die Einrichtung der technischen Infrastruktur, die für den Betrieb der neuen Community benötigt wird. Im zweiten Schritt wird dann die eigentliche Inbetriebnahme der neuen Community durchgeführt, bei der die notwendigen Registrierungsschritte für den fachlichen Austausch an Informationen zwischen den schon bestehenden Communities und der neuen Community erfolgt. Der erste Schritt wird hier im Kapitel Vorraussetzungen beschrieben. Der zweite Schritt dieses Prozesse erfolgt als Ablaufbeschreibung der Registrierungsschritte im Kapitel Ablauf. #### Vorraussetzungen +Um eine neue Community zu erstellen wird eine dafür speziell konzepierte Infrastruktur benötigt. Die technischen Details dieser Infrastruktur werden in der *technischen Infrastruktur Beschreibung* als eigenständiges Dokument dem Administrator der neuen Community zur Verfügung gestellt. Diese ist neben den Installationsskripten und Anwendungsdateien Teil des Auslieferungspaketes der Gradido-Anwendung. + +Sobald der Administrator die geforderte Infrastruktur in Betrieb genommen und darauf die entsprechenden Installationsskripte ausgeführt hat erfolgt die eigentliche Erstellung und Registrierung der neue Community. Das heißt beim erstmaligen Start der Gradido-Anwendung wird automatisch der Prozess *Neue Community erstellen* gestartet. + #### Ablauf +Der Prozess *Neue Community erstellen* wird entweder automatisiert beim erstmaligen Start der Gradido-Anwendung auf einer neuen Infrastruktur gestartet oder manuell, wenn eine neue Community auf einer schon bestehenden Infrastruktur zusätzlich eingerichtet werden soll. Die nachfolgende Ablaufgrafik zeigt die logischen Schritte, die in dem Prozess durchlaufen werden: + +![Ablauf Neue Community erstellen](./image/Ablauf_Neue_Community_erstellen.png) + #### Ende Status +1. Community-Infrastruktur ist installiert und aktiv +2. neue Community ist erzeugt und Daten in der Community-DB gespeichert +3. der Hintergrundprozess "Community-Vernetzung" ist am Laufen + * die initiale "newCommunity-Msg" mit den eigenen Community-Daten ist in den Public-Channel versendet + * ein Listener lauscht am Public-Channel auf Antworten (replyNewCommunityMsg) der schon existenten Communities + * ein Listener lauscht am Public-CHannel auf initiale "newCommunity-Msg" anderer neuer Communities +4. mit dem ersten Empfangen einer Reply-Msg einer anderen Community, wird der Community-Connection Prozess gestartet, der mit jedem Empfang von neuen Community-Daten eine P2P-Verbindung zu dieser Community aufbaut, um direkt detaillierte Daten auszutauschen +5. die vordefinierte Tätigkeitsliste ist geladen +6. die vordefinierten Berechtigungen sind aktiv +7. optional sind schon Mitglieder erfasst und in der Datenbank gespeichert + #### Fehlerfälle ### Community bearbeiten @@ -260,3 +331,78 @@ Die nachfolgenden Anwendungsfälle beschreiben die fachlichen Vorraussetzungen, #### Ende Status #### Fehlerfälle + +# Besprechung 19.08.2021 19:00 mit Bernd + +## Kreis-Mensch-Sein-Community + +Felix Kramer + +noch keine eigene Währung, wollen gerne Gradido + +haben auch aktives Grundeinkommen + +passt aber nicht ganz zur Gradido Philosophie, weil Gemeinwohlleistung zu unterschiedlich bewertet werden. + +-> Colored Gradido? + +Community-Creation + +GDD1 (gold) ist existent + +Felix baut GGD2-Infrastruktur auf + +* Frage: willst du GDD1(gold) oder eigene Währung? +* Antwort: nein ich will eigene GDD2 (rot) + * muss neue Währung erzeugen +* Antwort: ja, dann Anfrage an GDD1, dass GDD2 auch Goldene GDD1 schöpfen darf? + * Ja wird akzeptiert + * dann bekommt GDD2 die Lizenz goldene GDD1 schöpfen kann + +Kommt später heraus, dass GDD2 nicht mehr den goldenen Regeln entspricht, dann muss die Lizenz zum goldene GDD1 Schöpfen für GDD2 gesperrt werden. + +Bisher geschöpfte goldene GDD2 beleiben aber erhalten. + +Es darf keine Markierung des Bot-Mitglieds geben, da Missbrauch/Fehler möglich + +Identität für ein Mitglied muss Human/Nichthuman enthalten + +GDD2 muss mit Lizenzentzug wechseln auf eigene Währung um weiterschöpfen zu können. + +Mitgliederwechsel in andere Community muss dann auch Währungswechsel berücksichtigen. + +Bestcase: 1 Blockchain pro Währung + +GDD1(gold) existent + +GDD2(gold) soll gegründet werden + +GDD2 baut Infrasturktur auf + +Frage an GDD2, ob goldene oder andere? + +### Tätigkeiten, die von der Community aktzeptiert werden + +Nachweise für durchgeführte Tätigkeiten, bevor diese dem AGE-Konto gutgeschrieben werden? + +Liste der Tätigkeiten muss von Community erstellt, bestätigt und verwaltet werden + +Bei Tätigkeit von x Stunden für das AGE muss aus der Liste die passende Tätigkeit gewählt werden und per Nachweis (andere Mitglieder, Video, o.ä.) + +Bei Krankheit o.ä. muss es aber möglich sein, dass dennoch Geld auf das AGE-Konto kommt. + +| PR-Kommentar | | +| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Definition? Ist Faulheit eine Krankheit? | +| Claus-Peter 25.11.2021 | :-) Das kommt auf die solidarische Einstellung der Community an ;-)

da drängt sich mir die Gegenfrage auf: Bis zu welchem Alter bekommt ein Kind sein AGE-Geld geschöpft nur durch seine blos Existenz? Oder andersherum, ab und bis zu welchem Alter muss eine Gegenleistung erbracht werden, Stichworte: unbeschwerte Kindheit und wohlverdiente Altersruhe? | + + +Kontaktförderung durch gewichtete Tätigkeitsbestätigung ( bei mind. 2 Bestätigungen pro Tätigkeit muss mind. ein neues Mitglied dabei sein) + +Liste von Mitgliedern, die ich bestätigt habe: + +* Kontaktpflege +* Gewichtung +* Vernetzung + +Ricardo Leppe Podcast Lern und Memotechniken diff --git a/docu/Concepts/BusinessRequirements/RegelnDerGeldschoepfung.md b/docu/Concepts/BusinessRequirements/RegelnDerGeldschoepfung.md index 3ee3b5193..378241d06 100644 --- a/docu/Concepts/BusinessRequirements/RegelnDerGeldschoepfung.md +++ b/docu/Concepts/BusinessRequirements/RegelnDerGeldschoepfung.md @@ -1,3 +1,33 @@ # Regeln der Geldschöpfung -*Hier werden die fachlichen Regeln der 3-fachen Schöpfung beschrieben* +Nach der Gradido-Philosophie erfolgt pro Monat der Prozess der Dreifachen-Geldschöpfung. Das bedeutet, dass in einer Gradido-Community pro Mitglied, das eine *natürliche Person* ist, eine maximale Summe von 3.000 GDD geschöpft wird. Davon kann das Mitglied 1.000 GDD als *Aktives Grundeinkommen* durch Community nützige Leistungen auf sein persönliches AGE-Konto erhalten. 1.000 GDD werden auf das Gemeinwohlkonto der Community gutgeschrieben und weitere 1.000 GDD fließen auf das AUF-Konto der Community. + +| PR-Kommentar | | +| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Hier wird immer ausgespart wie sich die 3x 1000 GDD zueinander verhalten. Als ich Bernd gefragt habe sagte er, das aus Planungssicherheit immer die vollen 2000 GDD für die Community geschöpft werden. Das halte ich allerdings für sehr gefährlich, da es dazu verleitet einfach weitere Konten zu registrieren. Hinter dem geschöpftem Geld steht dann auch ggf keine Leistung und damit keine Deckung. Ich halte es für essentiell die Schöpfung für AUF & Community GDD auch an die konkrete Schöpfung des Nutzers zu binden, da diese leistungsgedeckt ist. | +| Claus-Peter 25.11.2021 | Das ist eine berechtigte Frage und muss echt konzeptionell weiter durchdacht werden.
Ein Hinweis zu dem Thema wäre noch, dass egal ob und wieviel eine Person in dem Giralgeldsystem verdient, die Kommune, in der diese Person den 1.Wohnsitz hat, auch Steuergelder zugewiesen bekommt. | + + +Um diese Schritte des Geldschöpfungsprozesses zu gewährleisten bedarf es einiger Vorraussetzungen, die im folgenden beschrieben werden. + +# Vorraussetzungen + +## Drei Kontenmodell + +## Verteilungsschlüssel + +## Tätigkeitsliste für Aktives Grundeinkommen + +Die Tätigkeitsliste für das AGE dient als Grundlage der gemeinnützigen Leistungen, die ein Mitglied sich anrechnen lassen kann. Das heißt eine Community muss eine Sammlung von Tätigkeiten erfassen, die von den Community-Mitgliedern als gemeinnützig empfunden und bestätigt werden. + +Das heißt die Community muss unter den Mitgliedern eine Liste erarbeiten, die alle Tätigkeiten enthält, aus denen sich ein Mitglied dann eine oder mehrere auswählen kann, um sich sein Aktives Grundeinkommen damit zu decken. Die einzelnen Tätigkeiten sollen auch fachlich strukturierbar sein z.B. Kunst, Soziales, Gesundheit, Produktion, etc. . Die Menge und Definition der einzelnen Tätigkeiten und Strukturen unterliegt einer stetigen Anpassung nach den Bedürfnissen der Community-Mitglieder, um den natürlichen Veränderungen des miteinander Lebens gerecht werden zu können. Ob zu einer Tätigkeitsbeschreibung auch gleich eine Wertigkeit definiert werden soll, ist noch unklar. Man kann aber sicherlich sagen, dass manche Tätigkeiten dem Gemeinwohl dienlicher sind als andere. Aber auch das ist wiederum eine Ansichtsache und muss unter den Community-Mitgliedern vereinbart werden. + +| PR-Kommentar | | +| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Ulf 07.11.2021 | Ich denke die Liste sollte sich aus den Tätigkeiten der anerkannten Leistungen zusammensetzen, folglich vollautomatisch entstehen.
Die Zuordnung jeder Leistung zu einer Kategorie halte ich allerdings für sehr gut, da es einen Vergleich und eine Bewertung von Communities zulässt "Das ist eine Handwerker Community" "Das sind ja nur Baumschmuser" | +| Claus-Peter 25.11.2021 | Ich denke im ersten Schritt können wir aus den bisher aufgelaufenen Tätigkeiten während der Transformationsphase eine Art Default-Liste erzeugen, die dann von den Communities weiter ergänzt/verändert, etc. werden.
Ob wir hier evtl. schon Schrittweise in den jetzigen Adminbereich Mechanismen einbauen sollten, um eine Gliederung und feste Vorschlagstexte der Tätigkeitsbezeichnungen zu gewinnen, sollten wir im Hinterkopf behalten. | + + +### Erstellung und Erfassung der Tätigkeiten + +# Prozess der Geldschöpfung diff --git a/docu/Concepts/BusinessRequirements/graphics/Ablauf_Neue_Community_erstellen.drawio b/docu/Concepts/BusinessRequirements/graphics/Ablauf_Neue_Community_erstellen.drawio new file mode 100644 index 000000000..161e78dbd --- /dev/null +++ b/docu/Concepts/BusinessRequirements/graphics/Ablauf_Neue_Community_erstellen.drawio @@ -0,0 +1,304 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docu/Concepts/BusinessRequirements/graphics/RegistrationProcess.drawio b/docu/Concepts/BusinessRequirements/graphics/RegistrationProcess.drawio new file mode 100644 index 000000000..4fd204ac6 --- /dev/null +++ b/docu/Concepts/BusinessRequirements/graphics/RegistrationProcess.drawio @@ -0,0 +1,254 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docu/Concepts/BusinessRequirements/image/Ablauf_Neue_Community_erstellen.png b/docu/Concepts/BusinessRequirements/image/Ablauf_Neue_Community_erstellen.png new file mode 100644 index 000000000..82f1664e3 Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/Ablauf_Neue_Community_erstellen.png differ diff --git a/docu/Concepts/BusinessRequirements/image/CommunityChannelCommunication.png b/docu/Concepts/BusinessRequirements/image/CommunityChannelCommunication.png new file mode 100644 index 000000000..c6af54bbe Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/CommunityChannelCommunication.png differ diff --git a/docu/Concepts/BusinessRequirements/image/CommunityCreationChannel.png b/docu/Concepts/BusinessRequirements/image/CommunityCreationChannel.png new file mode 100644 index 000000000..04168e154 Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/CommunityCreationChannel.png differ diff --git a/docu/Concepts/BusinessRequirements/image/CommunityNetwork.png b/docu/Concepts/BusinessRequirements/image/CommunityNetwork.png new file mode 100644 index 000000000..12ebbf5a1 Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/CommunityNetwork.png differ diff --git a/docu/Concepts/BusinessRequirements/image/LoginPageNewFrontend.png b/docu/Concepts/BusinessRequirements/image/LoginPageNewFrontend.png new file mode 100644 index 000000000..23d7704f8 Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/LoginPageNewFrontend.png differ diff --git a/docu/Concepts/BusinessRequirements/image/RegisterPageNewFrontend.png b/docu/Concepts/BusinessRequirements/image/RegisterPageNewFrontend.png new file mode 100644 index 000000000..e3bfd96d1 Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/RegisterPageNewFrontend.png differ diff --git a/docu/Concepts/BusinessRequirements/image/RegisterThxPageNewFrontend.png b/docu/Concepts/BusinessRequirements/image/RegisterThxPageNewFrontend.png new file mode 100644 index 000000000..623e12cbf Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/RegisterThxPageNewFrontend.png differ diff --git a/docu/Concepts/BusinessRequirements/image/RegistrationProcess.png b/docu/Concepts/BusinessRequirements/image/RegistrationProcess.png new file mode 100644 index 000000000..a615c5b8b Binary files /dev/null and b/docu/Concepts/BusinessRequirements/image/RegistrationProcess.png differ