📖New license file version [CI SKIP] [skip ci]

Reviewed-on: #109
Reviewed-by: Philipp Dormann <philipp@philippdormann.de>

.drone.yml

@@ -11,7 +11,7 @@ steps:
       - git checkout $DRONE_SOURCE_BRANCH
       - mv .env.ci .env
   - name: run tests
-    image: node:14.15.1-alpine3.12
+    image: node:latest
     commands:
       - yarn
       - yarn test:ci
@@ -23,8 +23,15 @@ trigger:
 kind: pipeline
 type: docker
 name: build:dev
+clone:
+  disable: true
 
 steps:
+  - name: clone
+    image: alpine/git
+    commands:
+      - git clone $DRONE_REMOTE_URL .
+      - git checkout dev
   - name: build dev
     image: plugins/docker
     depends_on: [clone]
@@ -37,6 +44,22 @@ steps:
       tags:
         - dev
       registry: registry.odit.services
+  - name: run changelog export
+    depends_on: ["clone"]
+    image: node:latest
+    commands:
+      - npx auto-changelog --commit-limit false -p -u --hide-credit
+  - name: push new changelog to repo
+    depends_on: ["run changelog export"]
+    image: appleboy/drone-git-push
+    settings:
+      branch: dev
+      commit: true
+      commit_message: 🧾New changelog file version [CI SKIP] [skip ci]
+      author_email: bot@odit.services
+      remote: git@git.odit.services:lfk/backend.git
+      ssh_key:
+        from_secret: GITLAB_SSHKEY
   - name: run full license export
     depends_on: ["clone"]
     image: node:14.15.1-alpine3.12
@@ -49,12 +72,14 @@ steps:
     settings:
       branch: dev
       commit: true
-      commit_message: new license file version [CI SKIP]
+      commit_message: 📖New license file version [CI SKIP] [skip ci]
       author_email: bot@odit.services
       remote: git@git.odit.services:lfk/backend.git
+      skip_verify: true
       ssh_key:
         from_secret: GITLAB_SSHKEY
 
+
 trigger:
   branch:
     - dev
@@ -65,11 +90,20 @@ trigger:
 kind: pipeline
 type: docker
 name: build:latest
+clone:
+  disable: true
 
 steps:
+  - name: clone
+    image: alpine/git
+    commands:
+      - git clone $DRONE_REMOTE_URL .
+      - git checkout dev
+      - git merge main
+      - git checkout main
   - name: build latest
+    depends_on: ["clone"]
     image: plugins/docker
-    depends_on: [clone]
     settings:
       username:
         from_secret: DOCKER_REGISTRY_USER
@@ -79,6 +113,15 @@ steps:
       tags:
         - latest
       registry: registry.odit.services
+  - name: push merge to repo
+    depends_on: ["clone"]
+    image: appleboy/drone-git-push
+    settings:
+      branch: dev
+      commit: false
+      remote: git@git.odit.services:lfk/backend.git
+      ssh_key:
+        from_secret: GITLAB_SSHKEY
 
 trigger:
   branch:

.env.ci

@@ -6,4 +6,4 @@ DB_USER=unused
 DB_PASSWORD=bla
 DB_NAME=./test.sqlite
 NODE_ENV=dev
-POSTALCODE_COUNTRYCODE=null
+POSTALCODE_COUNTRYCODE=DE

.env.example

@@ -6,4 +6,4 @@ DB_USER=bla
 DB_PASSWORD=bla
 DB_NAME=bla
 NODE_ENV=production
-POSTALCODE_COUNTRYCODE=null
+POSTALCODE_COUNTRYCODE=DE

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odit/lfk-backend",
-  "version": "0.0.11",
+  "version": "0.2.0",
   "main": "src/app.ts",
   "repository": "https://git.odit.services/lfk/backend",
   "author": {
@@ -22,11 +22,11 @@
   ],
   "license": "CC-BY-NC-SA-4.0",
   "dependencies": {
+    "@odit/class-validator-jsonschema": "2.1.1",
     "argon2": "^0.27.1",
     "body-parser": "^1.19.0",
-    "class-transformer": "^0.3.1",
-    "class-validator": "^0.12.2",
-    "class-validator-jsonschema": "^2.1.0",
+    "class-transformer": "0.3.1",
+    "class-validator": "^0.13.1",
     "consola": "^2.15.0",
     "cookie": "^0.4.1",
     "cookie-parser": "^1.4.5",
@@ -35,6 +35,7 @@
     "dotenv": "^8.2.0",
     "express": "^4.17.1",
     "jsonwebtoken": "^8.5.1",
+    "libphonenumber-js": "^1.9.7",
     "mysql": "^2.18.1",
     "pg": "^8.5.1",
     "reflect-metadata": "^0.1.13",
@@ -78,16 +79,16 @@
     "seed": "ts-node ./node_modules/typeorm/cli.js schema:sync && ts-node ./node_modules/typeorm-seeding/dist/cli.js seed",
     "openapi:export": "ts-node scripts/openapi_export.ts",
     "licenses:export": "license-exporter --md",
-    "release": "release-it"
+    "release": "release-it --only-version"
   },
   "release-it": {
     "git": {
+      "commit": true,
       "requireCleanWorkingDir": false,
-      "requireBranch": "main",
+      "commitMessage": "🚀Bumped version to v${version}",
+      "requireBranch": "dev",
       "push": false,
-      "tag": true,
-      "tagName": "v${version}",
-      "tagAnnotation": "v${version}"
+      "tag": false
     },
     "npm": {
       "publish": false
@@ -99,4 +100,4 @@
       "docs/*"
     ]
   }
-}
+}

scripts/openapi_export.ts

@@ -1,4 +1,4 @@
-import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
+import { validationMetadatasToSchemas } from '@odit/class-validator-jsonschema';
 import consola from "consola";
 import fs from "fs";
 import "reflect-metadata";

src/apispec.ts

@@ -1,5 +1,6 @@
 import { MetadataArgsStorage } from 'routing-controllers';
 import { routingControllersToSpec } from 'routing-controllers-openapi';
+import { config } from './config';
 
 /**
  * This function generates a the openapi spec from route metadata and type schemas.
@@ -43,7 +44,7 @@ export function generateSpec(storage: MetadataArgsStorage, schemas) {
             info: {
                 description: "The the backend API for the LfK! runner system.",
                 title: "LfK! Backend API",
-                version: process.env.npm_package_version
+                version: config.version
             },
         }
     );

src/app.ts

@@ -5,10 +5,12 @@ import { config, e as errors } from './config';
 import loaders from "./loaders/index";
 import authchecker from "./middlewares/authchecker";
 import { ErrorHandler } from './middlewares/ErrorHandler';
+import UserChecker from './middlewares/UserChecker';
 
 const CONTROLLERS_FILE_EXTENSION = process.env.NODE_ENV === 'production' ? 'js' : 'ts';
 const app = createExpressServer({
   authorizationChecker: authchecker,
+  currentUserChecker: UserChecker,
   middlewares: [ErrorHandler],
   development: config.development,
   cors: true,

src/config.ts

@@ -1,4 +1,5 @@
 import { config as configDotenv } from 'dotenv';
+import { CountryCode } from 'libphonenumber-js';
 import ValidatorJS from 'validator';
 
 configDotenv();
@@ -6,22 +7,20 @@ export const config = {
     internal_port: parseInt(process.env.APP_PORT) || 4010,
     development: process.env.NODE_ENV === "production",
     jwt_secret: process.env.JWT_SECRET || "secretjwtsecret",
-    phone_validation_countrycode: process.env.PHONE_COUNTRYCODE || "ZZ",
-    postalcode_validation_countrycode: getPostalCodeLocale()
+    phone_validation_countrycode: getPhoneCodeLocale(),
+    postalcode_validation_countrycode: getPostalCodeLocale(),
+    version: process.env.VERSION || require('../package.json').version
 }
 let errors = 0
 if (typeof config.internal_port !== "number") {
     errors++
 }
-if (typeof config.phone_validation_countrycode !== "string") {
-    errors++
-}
-if (config.phone_validation_countrycode.length !== 2) {
-    errors++
-}
 if (typeof config.development !== "boolean") {
     errors++
 }
+function getPhoneCodeLocale(): CountryCode {
+    return (process.env.PHONE_COUNTRYCODE as CountryCode);
+}
 function getPostalCodeLocale(): any {
     try {
         const stringArray: String[] = ValidatorJS.isPostalCodeLocales;

src/controllers/DonationController.ts

@@ -0,0 +1,145 @@
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnectionManager, Repository } from 'typeorm';
+import { DonationIdsNotMatchingError, DonationNotFoundError } from '../errors/DonationErrors';
+import { DonorNotFoundError } from '../errors/DonorErrors';
+import { RunnerNotFoundError } from '../errors/RunnerErrors';
+import { CreateDistanceDonation } from '../models/actions/create/CreateDistanceDonation';
+import { CreateFixedDonation } from '../models/actions/create/CreateFixedDonation';
+import { UpdateDistanceDonation } from '../models/actions/update/UpdateDistanceDonation';
+import { UpdateFixedDonation } from '../models/actions/update/UpdateFixedDonation';
+import { DistanceDonation } from '../models/entities/DistanceDonation';
+import { Donation } from '../models/entities/Donation';
+import { FixedDonation } from '../models/entities/FixedDonation';
+import { ResponseDistanceDonation } from '../models/responses/ResponseDistanceDonation';
+import { ResponseDonation } from '../models/responses/ResponseDonation';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+
+@JsonController('/donations')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class DonationController {
+	private donationRepository: Repository<Donation>;
+	private distanceDonationRepository: Repository<DistanceDonation>;
+	private fixedDonationRepository: Repository<FixedDonation>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.donationRepository = getConnectionManager().get().getRepository(Donation);
+		this.distanceDonationRepository = getConnectionManager().get().getRepository(DistanceDonation);
+		this.fixedDonationRepository = getConnectionManager().get().getRepository(FixedDonation);
+	}
+
+	@Get()
+	@Authorized("DONATION:GET")
+	@ResponseSchema(ResponseDonation, { isArray: true })
+	@ResponseSchema(ResponseDistanceDonation, { isArray: true })
+	@OpenAPI({ description: 'Lists all donations (fixed or distance based) from all donors. <br> This includes the donations\'s runner\'s distance ran(if distance donation).' })
+	async getAll() {
+		let responseDonations: ResponseDonation[] = new Array<ResponseDonation>();
+		const donations = await this.donationRepository.find({ relations: ['runner', 'donor', 'runner.scans', 'runner.scans.track'] });
+		donations.forEach(donation => {
+			responseDonations.push(donation.toResponse());
+		});
+		return responseDonations;
+	}
+
+	@Get('/:id')
+	@Authorized("DONATION:GET")
+	@ResponseSchema(ResponseDonation)
+	@ResponseSchema(ResponseDistanceDonation)
+	@ResponseSchema(DonationNotFoundError, { statusCode: 404 })
+	@OnUndefined(DonationNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the donation whose id got provided. This includes the donation\'s runner\'s distance ran (if distance donation).' })
+	async getOne(@Param('id') id: number) {
+		let donation = await this.donationRepository.findOne({ id: id }, { relations: ['runner', 'donor', 'runner.scans', 'runner.scans.track'] })
+		if (!donation) { throw new DonationNotFoundError(); }
+		return donation.toResponse();
+	}
+
+	@Post('/fixed')
+	@Authorized("DONATION:CREATE")
+	@ResponseSchema(ResponseDonation)
+	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a fixed donation (not distance donation - use /donations/distance instead). <br> Please rmemember to provide the donation\'s donors\'s id and amount.' })
+	async postFixed(@Body({ validate: true }) createDonation: CreateFixedDonation) {
+		let donation = await createDonation.toEntity();
+		donation = await this.fixedDonationRepository.save(donation);
+		return (await this.donationRepository.findOne({ id: donation.id }, { relations: ['donor'] })).toResponse();
+	}
+
+	@Post('/distance')
+	@Authorized("DONATION:CREATE")
+	@ResponseSchema(ResponseDistanceDonation)
+	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a distance donation (not fixed donation - use /donations/fixed instead). <br> Please rmemember to provide the donation\'s donors\'s and runner\s ids and amount per distance (kilometer).' })
+	async postDistance(@Body({ validate: true }) createDonation: CreateDistanceDonation) {
+		let donation = await createDonation.toEntity();
+		donation = await this.distanceDonationRepository.save(donation);
+		return (await this.donationRepository.findOne({ id: donation.id }, { relations: ['runner', 'donor', 'runner.scans', 'runner.scans.track'] })).toResponse();
+	}
+
+	@Put('/fixed/:id')
+	@Authorized("DONATION:UPDATE")
+	@ResponseSchema(ResponseDonation)
+	@ResponseSchema(DonationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(DonationIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the fixed donation (not distance donation - use /donations/distance instead) whose id you provided. <br> Please remember that ids can't be changed and amounts must be positive." })
+	async putFixed(@Param('id') id: number, @Body({ validate: true }) donation: UpdateFixedDonation) {
+		let oldDonation = await this.fixedDonationRepository.findOne({ id: id });
+
+		if (!oldDonation) {
+			throw new DonationNotFoundError();
+		}
+
+		if (oldDonation.id != donation.id) {
+			throw new DonationIdsNotMatchingError();
+		}
+
+		await this.fixedDonationRepository.save(await donation.update(oldDonation));
+		return (await this.donationRepository.findOne({ id: donation.id }, { relations: ['donor'] })).toResponse();
+	}
+
+	@Put('/distance/:id')
+	@Authorized("DONATION:UPDATE")
+	@ResponseSchema(ResponseDonation)
+	@ResponseSchema(DonationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(DonationIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the distance donation (not fixed donation - use /donations/fixed instead) whose id you provided. <br> Please remember that ids can't be changed and amountPerDistance must be positive." })
+	async putDistance(@Param('id') id: number, @Body({ validate: true }) donation: UpdateDistanceDonation) {
+		let oldDonation = await this.distanceDonationRepository.findOne({ id: id });
+
+		if (!oldDonation) {
+			throw new DonationNotFoundError();
+		}
+
+		if (oldDonation.id != donation.id) {
+			throw new DonationIdsNotMatchingError();
+		}
+
+		await this.distanceDonationRepository.save(await donation.update(oldDonation));
+		return (await this.donationRepository.findOne({ id: donation.id }, { relations: ['runner', 'donor', 'runner.scans', 'runner.scans.track'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("DONATION:DELETE")
+	@ResponseSchema(ResponseDonation)
+	@ResponseSchema(ResponseDistanceDonation)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the donation whose id you provided. <br> If no donation with this id exists it will just return 204(no content).' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let donation = await this.donationRepository.findOne({ id: id });
+		if (!donation) { return null; }
+		const responseScan = await this.donationRepository.findOne({ id: donation.id }, { relations: ['runner', 'donor', 'runner.scans', 'runner.scans.track'] });
+
+		await this.donationRepository.delete(donation);
+		return responseScan.toResponse();
+	}
+}

src/controllers/DonorController.ts

@@ -1,12 +1,13 @@
 import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { DonorIdsNotMatchingError, DonorNotFoundError } from '../errors/DonorErrors';
+import { DonorHasDonationsError, DonorIdsNotMatchingError, DonorNotFoundError } from '../errors/DonorErrors';
 import { CreateDonor } from '../models/actions/create/CreateDonor';
 import { UpdateDonor } from '../models/actions/update/UpdateDonor';
 import { Donor } from '../models/entities/Donor';
 import { ResponseDonor } from '../models/responses/ResponseDonor';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { DonationController } from './DonationController';
 
 @JsonController('/donors')
 @OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
@@ -23,10 +24,10 @@ export class DonorController {
 	@Get()
 	@Authorized("DONOR:GET")
 	@ResponseSchema(ResponseDonor, { isArray: true })
-	@OpenAPI({ description: 'Lists all runners from all teams/orgs. <br> This includes the runner\'s group and distance ran.' })
+	@OpenAPI({ description: 'Lists all donor. <br> This includes the donor\'s current donation amount.' })
 	async getAll() {
 		let responseDonors: ResponseDonor[] = new Array<ResponseDonor>();
-		const donors = await this.donorRepository.find();
+		const donors = await this.donorRepository.find({ relations: ['donations', 'donations.runner', 'donations.runner.scans', 'donations.runner.scans.track'] });
 		donors.forEach(donor => {
 			responseDonors.push(new ResponseDonor(donor));
 		});
@@ -38,9 +39,9 @@ export class DonorController {
 	@ResponseSchema(ResponseDonor)
 	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
 	@OnUndefined(DonorNotFoundError)
-	@OpenAPI({ description: 'Lists all information about the runner whose id got provided.' })
+	@OpenAPI({ description: 'Lists all information about the donor whose id got provided. <br> This includes the donor\'s current donation amount.' })
 	async getOne(@Param('id') id: number) {
-		let donor = await this.donorRepository.findOne({ id: id })
+		let donor = await this.donorRepository.findOne({ id: id }, { relations: ['donations', 'donations.runner', 'donations.runner.scans', 'donations.runner.scans.track'] })
 		if (!donor) { throw new DonorNotFoundError(); }
 		return new ResponseDonor(donor);
 	}
@@ -48,7 +49,7 @@ export class DonorController {
 	@Post()
 	@Authorized("DONOR:CREATE")
 	@ResponseSchema(ResponseDonor)
-	@OpenAPI({ description: 'Create a new runner. <br> Please remeber to provide the runner\'s group\'s id.' })
+	@OpenAPI({ description: 'Create a new donor.' })
 	async post(@Body({ validate: true }) createRunner: CreateDonor) {
 		let donor;
 		try {
@@ -58,7 +59,7 @@ export class DonorController {
 		}
 
 		donor = await this.donorRepository.save(donor)
-		return new ResponseDonor(await this.donorRepository.findOne(donor));
+		return new ResponseDonor(await this.donorRepository.findOne(donor, { relations: ['donations', 'donations.runner', 'donations.runner.scans', 'donations.runner.scans.track'] }));
 	}
 
 	@Put('/:id')
@@ -66,7 +67,7 @@ export class DonorController {
 	@ResponseSchema(ResponseDonor)
 	@ResponseSchema(DonorNotFoundError, { statusCode: 404 })
 	@ResponseSchema(DonorIdsNotMatchingError, { statusCode: 406 })
-	@OpenAPI({ description: "Update the runner whose id you provided. <br> Please remember that ids can't be changed." })
+	@OpenAPI({ description: "Update the donor whose id you provided. <br> Please remember that ids can't be changed." })
 	async put(@Param('id') id: number, @Body({ validate: true }) donor: UpdateDonor) {
 		let oldDonor = await this.donorRepository.findOne({ id: id });
 
@@ -79,7 +80,7 @@ export class DonorController {
 		}
 
 		await this.donorRepository.save(await donor.update(oldDonor));
-		return new ResponseDonor(await this.donorRepository.findOne({ id: id }));
+		return new ResponseDonor(await this.donorRepository.findOne({ id: id }, { relations: ['donations', 'donations.runner', 'donations.runner.scans', 'donations.runner.scans.track'] }));
 	}
 
 	@Delete('/:id')
@@ -87,17 +88,24 @@ export class DonorController {
 	@ResponseSchema(ResponseDonor)
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the runner whose id you provided. <br> If no runner with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the donor whose id you provided. <br> If no donor with this id exists it will just return 204(no content). <br> If the donor still has donations associated this will fail, please provide the query param ?force=true to delete the donor with all associated donations.' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let donor = await this.donorRepository.findOne({ id: id });
 		if (!donor) { return null; }
-		const responseDonor = await this.donorRepository.findOne(donor);
+		const responseDonor = await this.donorRepository.findOne(donor, { relations: ['donations', 'donations.runner', 'donations.runner.scans', 'donations.runner.scans.track'] });
 
 		if (!donor) {
 			throw new DonorNotFoundError();
 		}
 
-		//TODO: DELETE DONATIONS AND WARN FOR FORCE (https://git.odit.services/lfk/backend/issues/66)
+		const donorDonations = (await this.donorRepository.findOne({ id: donor.id }, { relations: ["donations"] })).donations;
+		if (donorDonations.length > 0 && !force) {
+			throw new DonorHasDonationsError();
+		}
+		const donationController = new DonationController();
+		for (let donation of donorDonations) {
+			await donationController.remove(donation.id, force);
+		}
 
 		await this.donorRepository.delete(donor);
 		return new ResponseDonor(responseDonor);

src/controllers/GroupContactController.ts

@@ -0,0 +1,107 @@
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnection, getConnectionManager, Repository } from 'typeorm';
+import { GroupContactIdsNotMatchingError, GroupContactNotFoundError } from '../errors/GroupContactErrors';
+import { RunnerGroupNotFoundError } from '../errors/RunnerGroupErrors';
+import { CreateGroupContact } from '../models/actions/create/CreateGroupContact';
+import { UpdateGroupContact } from '../models/actions/update/UpdateGroupContact';
+import { GroupContact } from '../models/entities/GroupContact';
+import { RunnerGroup } from '../models/entities/RunnerGroup';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseGroupContact } from '../models/responses/ResponseGroupContact';
+
+@JsonController('/contacts')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class GroupContactController {
+	private contactRepository: Repository<GroupContact>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.contactRepository = getConnectionManager().get().getRepository(GroupContact);
+	}
+
+	@Get()
+	@Authorized("CONTACT:GET")
+	@ResponseSchema(ResponseGroupContact, { isArray: true })
+	@OpenAPI({ description: 'Lists all contacts. <br> This includes the contact\'s associated groups.' })
+	async getAll() {
+		let responseContacts: ResponseGroupContact[] = new Array<ResponseGroupContact>();
+		const contacts = await this.contactRepository.find({ relations: ['groups'] });
+		contacts.forEach(contact => {
+			responseContacts.push(contact.toResponse());
+		});
+		return responseContacts;
+	}
+
+	@Get('/:id')
+	@Authorized("CONTACT:GET")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(GroupContactNotFoundError, { statusCode: 404 })
+	@OnUndefined(GroupContactNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the contact whose id got provided. <br> This includes the contact\'s associated groups.' })
+	async getOne(@Param('id') id: number) {
+		let contact = await this.contactRepository.findOne({ id: id }, { relations: ['groups'] })
+		if (!contact) { throw new GroupContactNotFoundError(); }
+		return contact.toResponse();
+	}
+
+	@Post()
+	@Authorized("CONTACT:CREATE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(RunnerGroupNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new contact.' })
+	async post(@Body({ validate: true }) createContact: CreateGroupContact) {
+		let contact;
+		try {
+			contact = await createContact.toEntity();
+		} catch (error) {
+			throw error;
+		}
+
+		contact = await this.contactRepository.save(contact)
+		return (await this.contactRepository.findOne({ id: contact.id }, { relations: ['groups'] })).toResponse();
+	}
+
+	@Put('/:id')
+	@Authorized("CONTACT:UPDATE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(GroupContactNotFoundError, { statusCode: 404 })
+	@ResponseSchema(GroupContactIdsNotMatchingError, { statusCode: 406 })
+	@ResponseSchema(RunnerGroupNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: "Update the contact whose id you provided. <br> Please remember that ids can't be changed." })
+	async put(@Param('id') id: number, @Body({ validate: true }) contact: UpdateGroupContact) {
+		let oldContact = await this.contactRepository.findOne({ id: id });
+
+		if (!oldContact) {
+			throw new GroupContactNotFoundError();
+		}
+
+		if (oldContact.id != contact.id) {
+			throw new GroupContactIdsNotMatchingError();
+		}
+
+		await this.contactRepository.save(await contact.update(oldContact));
+		return (await this.contactRepository.findOne({ id: contact.id }, { relations: ['groups'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("CONTACT:DELETE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the contact whose id you provided. <br> If no contact with this id exists it will just return 204(no content). <br> This won\'t delete any groups associated with the contact.' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let contact = await this.contactRepository.findOne({ id: id });
+		if (!contact) { return null; }
+		const responseContact = await this.contactRepository.findOne(contact, { relations: ['groups'] });
+		for (let group of responseContact.groups) {
+			group.contact = null;
+			await getConnection().getRepository(RunnerGroup).save(group);
+		}
+
+		await this.contactRepository.delete(contact);
+		return responseContact.toResponse();
+	}
+}

src/controllers/MeController.ts

@@ -0,0 +1,86 @@
+import { Body, CurrentUser, Delete, Get, JsonController, OnUndefined, Put, QueryParam } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnectionManager, Repository } from 'typeorm';
+import { UserDeletionNotConfirmedError, UserIdsNotMatchingError, UsernameContainsIllegalCharacterError, UserNotFoundError } from '../errors/UserErrors';
+import { UpdateUser } from '../models/actions/update/UpdateUser';
+import { User } from '../models/entities/User';
+import { ResponseUser } from '../models/responses/ResponseUser';
+import { ResponseUserPermissions } from '../models/responses/ResponseUserPermissions';
+import { PermissionController } from './PermissionController';
+
+
+@JsonController('/users/me')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class MeController {
+	private userRepository: Repository<User>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.userRepository = getConnectionManager().get().getRepository(User);
+	}
+
+	@Get('/')
+	@ResponseSchema(ResponseUser)
+	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@OnUndefined(UserNotFoundError)
+	@OpenAPI({ description: 'Lists all information about yourself.' })
+	async get(@CurrentUser() currentUser: User) {
+		let user = await this.userRepository.findOne({ id: currentUser.id }, { relations: ['permissions', 'groups', 'groups.permissions', 'permissions.principal', 'groups.permissions.principal'] })
+		if (!user) { throw new UserNotFoundError(); }
+		return new ResponseUser(user);
+	}
+
+	@Get('/')
+	@ResponseSchema(ResponseUserPermissions)
+	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@OnUndefined(UserNotFoundError)
+	@OpenAPI({ description: 'Lists all permissions granted to the you sorted into directly granted and inherited as permission response objects.' })
+	async getPermissions(@CurrentUser() currentUser: User) {
+		let user = await this.userRepository.findOne({ id: currentUser.id }, { relations: ['permissions', 'groups', 'groups.permissions', 'permissions.principal', 'groups.permissions.principal'] })
+		if (!user) { throw new UserNotFoundError(); }
+		return new ResponseUserPermissions(user);
+	}
+
+	@Put('/')
+	@ResponseSchema(ResponseUser)
+	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@ResponseSchema(UserIdsNotMatchingError, { statusCode: 406 })
+	@ResponseSchema(UsernameContainsIllegalCharacterError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the yourself. <br> You can't edit your own permissions or group memberships here - Please use the /api/users/:id enpoint instead. <br> Please remember that ids can't be changed." })
+	async put(@CurrentUser() currentUser: User, @Body({ validate: true }) updateUser: UpdateUser) {
+		let oldUser = await this.userRepository.findOne({ id: currentUser.id }, { relations: ['groups'] });
+		updateUser.groups = oldUser.groups.map(g => g.id);
+
+		if (!oldUser) {
+			throw new UserNotFoundError();
+		}
+
+		if (oldUser.id != updateUser.id) {
+			throw new UserIdsNotMatchingError();
+		}
+		await this.userRepository.save(await updateUser.update(oldUser));
+
+		return new ResponseUser(await this.userRepository.findOne({ id: currentUser.id }, { relations: ['permissions', 'groups', 'groups.permissions'] }));
+	}
+
+	@Delete('/')
+	@ResponseSchema(ResponseUser)
+	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@ResponseSchema(UserDeletionNotConfirmedError, { statusCode: 406 })
+	@OpenAPI({ description: 'Delete yourself. <br> You have to confirm your decision by providing the ?force=true query param. <br> If there are any permissions directly granted to you they will get deleted as well.' })
+	async remove(@CurrentUser() currentUser: User, @QueryParam("force") force: boolean) {
+		if (!force) { throw new UserDeletionNotConfirmedError; }
+		if (!currentUser) { return UserNotFoundError; }
+		const responseUser = await this.userRepository.findOne({ id: currentUser.id }, { relations: ['permissions', 'groups', 'groups.permissions'] });;
+
+		const permissionControler = new PermissionController();
+		for (let permission of responseUser.permissions) {
+			await permissionControler.remove(permission.id, true);
+		}
+
+		await this.userRepository.delete(currentUser);
+		return new ResponseUser(responseUser);
+	}
+}

src/controllers/PermissionController.ts

@@ -90,7 +90,7 @@ export class PermissionController {
         if (oldPermission.id != permission.id) {
             throw new PermissionIdsNotMatchingError();
         }
-        let existingPermission = await this.permissionRepository.findOne({ target: permission.target, action: permission.action, principal: permission.principal }, { relations: ['principal'] });
+        let existingPermission = await this.permissionRepository.findOne({ target: permission.target, action: permission.action, principal: await permission.getPrincipal() }, { relations: ['principal'] });
         if (existingPermission) {
             await this.remove(permission.id, true);
             return new ResponsePermission(existingPermission);

src/controllers/RunnerController.ts

@@ -1,13 +1,14 @@
 import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { RunnerGroupNeededError, RunnerIdsNotMatchingError, RunnerNotFoundError } from '../errors/RunnerErrors';
+import { RunnerGroupNeededError, RunnerHasDistanceDonationsError, RunnerIdsNotMatchingError, RunnerNotFoundError } from '../errors/RunnerErrors';
 import { RunnerGroupNotFoundError } from '../errors/RunnerGroupErrors';
 import { CreateRunner } from '../models/actions/create/CreateRunner';
 import { UpdateRunner } from '../models/actions/update/UpdateRunner';
 import { Runner } from '../models/entities/Runner';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseRunner } from '../models/responses/ResponseRunner';
+import { DonationController } from './DonationController';
 import { RunnerCardController } from './RunnerCardController';
 import { ScanController } from './ScanController';
 
@@ -91,6 +92,7 @@ export class RunnerController {
 	@Authorized("RUNNER:DELETE")
 	@ResponseSchema(ResponseRunner)
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(RunnerHasDistanceDonationsError, { statusCode: 406 })
 	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete the runner whose id you provided. <br> This will also delete all scans and cards associated with the runner. <br> If no runner with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
@@ -102,10 +104,19 @@ export class RunnerController {
 			throw new RunnerNotFoundError();
 		}
 
+		const runnerDonations = (await this.runnerRepository.findOne({ id: runner.id }, { relations: ["distanceDonations"] })).distanceDonations;
+		if (runnerDonations.length > 0 && !force) {
+			throw new RunnerHasDistanceDonationsError();
+		}
+		const donationController = new DonationController();
+		for (let donation of runnerDonations) {
+			await donationController.remove(donation.id, force);
+		}
+
 		const runnerCards = (await this.runnerRepository.findOne({ id: runner.id }, { relations: ["cards"] })).cards;
 		const cardController = new RunnerCardController;
-		for (let scan of runnerCards) {
-			await cardController.remove(scan.id, force);
+		for (let card of runnerCards) {
+			await cardController.remove(card.id, force);
 		}
 
 		const runnerScans = (await this.runnerRepository.findOne({ id: runner.id }, { relations: ["scans"] })).scans;

src/controllers/RunnerOrganisationController.ts

@@ -29,7 +29,7 @@ export class RunnerOrganisationController {
 	@OpenAPI({ description: 'Lists all organisations. <br> This includes their address, contact and teams (if existing/associated).' })
 	async getAll() {
 		let responseTeams: ResponseRunnerOrganisation[] = new Array<ResponseRunnerOrganisation>();
-		const runners = await this.runnerOrganisationRepository.find({ relations: ['address', 'contact', 'teams'] });
+		const runners = await this.runnerOrganisationRepository.find({ relations: ['contact', 'teams'] });
 		runners.forEach(runner => {
 			responseTeams.push(new ResponseRunnerOrganisation(runner));
 		});
@@ -43,7 +43,7 @@ export class RunnerOrganisationController {
 	@OnUndefined(RunnerOrganisationNotFoundError)
 	@OpenAPI({ description: 'Lists all information about the organisation whose id got provided.' })
 	async getOne(@Param('id') id: number) {
-		let runnerOrg = await this.runnerOrganisationRepository.findOne({ id: id }, { relations: ['address', 'contact', 'teams'] });
+		let runnerOrg = await this.runnerOrganisationRepository.findOne({ id: id }, { relations: ['contact', 'teams'] });
 		if (!runnerOrg) { throw new RunnerOrganisationNotFoundError(); }
 		return new ResponseRunnerOrganisation(runnerOrg);
 	}
@@ -62,7 +62,7 @@ export class RunnerOrganisationController {
 
 		runnerOrganisation = await this.runnerOrganisationRepository.save(runnerOrganisation);
 
-		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(runnerOrganisation, { relations: ['address', 'contact', 'teams'] }));
+		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(runnerOrganisation, { relations: ['contact', 'teams'] }));
 	}
 
 	@Put('/:id')
@@ -84,7 +84,7 @@ export class RunnerOrganisationController {
 
 		await this.runnerOrganisationRepository.save(await updateOrganisation.update(oldRunnerOrganisation));
 
-		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['address', 'contact', 'teams'] }));
+		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['contact', 'teams'] }));
 	}
 
 	@Delete('/:id')
@@ -94,11 +94,11 @@ export class RunnerOrganisationController {
 	@ResponseSchema(RunnerOrganisationHasTeamsError, { statusCode: 406 })
 	@ResponseSchema(RunnerOrganisationHasRunnersError, { statusCode: 406 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the organsisation whose id you provided. <br> If the organisation still has runners and/or teams associated this will fail. <br> To delete the organisation with all associated runners and teams set the force QueryParam to true (cascading deletion might take a while). <br> If no organisation with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the organsisation whose id you provided. <br> If the organisation still has runners and/or teams associated this will fail. <br> To delete the organisation with all associated runners and teams set the force QueryParam to true (cascading deletion might take a while). <br> This won\'t delete the associated contact. <br> If no organisation with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let organisation = await this.runnerOrganisationRepository.findOne({ id: id });
 		if (!organisation) { return null; }
-		let runnerOrganisation = await this.runnerOrganisationRepository.findOne(organisation, { relations: ['address', 'contact', 'runners', 'teams'] });
+		let runnerOrganisation = await this.runnerOrganisationRepository.findOne(organisation, { relations: ['contact', 'runners', 'teams'] });
 
 		if (!force) {
 			if (runnerOrganisation.teams.length != 0) {

src/controllers/RunnerTeamController.ts

@@ -93,7 +93,7 @@ export class RunnerTeamController {
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@ResponseSchema(RunnerTeamHasRunnersError, { statusCode: 406 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the team whose id you provided. <br> If the team still has runners associated this will fail. <br> To delete the team with all associated runners set the force QueryParam to true (cascading deletion might take a while). <br> If no team with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the team whose id you provided. <br> If the team still has runners associated this will fail. <br> To delete the team with all associated runners set the force QueryParam to true (cascading deletion might take a while). <br> This won\'t delete the associated contact.<br> If no team with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let team = await this.runnerTeamRepository.findOne({ id: id });
 		if (!team) { return null; }

src/controllers/StatusController.ts

@@ -1,11 +1,12 @@
 import { Get, JsonController } from 'routing-controllers';
 import { OpenAPI } from 'routing-controllers-openapi';
 import { getConnection } from 'typeorm';
+import { config } from '../config';
 
-@JsonController('/status')
+@JsonController()
 export class StatusController {
 
-    @Get()
+    @Get('/status')
     @OpenAPI({ description: "A very basic status/health endpoint that just checks if the database connection is available. <br> The available information depth will be expanded later." })
     get() {
         let connection;
@@ -19,4 +20,12 @@ export class StatusController {
             "database connection": "✔"
         };
     }
+
+    @Get('/version')
+    @OpenAPI({ description: "A very basic endpoint that just returns the curent package version." })
+    getVersion() {
+        return {
+            "version": config.version
+        }
+    }
 }

src/controllers/UserController.ts

@@ -1,13 +1,14 @@
 import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { UserIdsNotMatchingError, UserNotFoundError } from '../errors/UserErrors';
+import { UserDeletionNotConfirmedError, UserIdsNotMatchingError, UsernameContainsIllegalCharacterError, UserNotFoundError } from '../errors/UserErrors';
 import { UserGroupNotFoundError } from '../errors/UserGroupErrors';
 import { CreateUser } from '../models/actions/create/CreateUser';
 import { UpdateUser } from '../models/actions/update/UpdateUser';
 import { User } from '../models/entities/User';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseUser } from '../models/responses/ResponseUser';
+import { ResponseUserPermissions } from '../models/responses/ResponseUserPermissions';
 import { PermissionController } from './PermissionController';
 
 
@@ -26,7 +27,7 @@ export class UserController {
 	@Get()
 	@Authorized("USER:GET")
 	@ResponseSchema(ResponseUser, { isArray: true })
-	@OpenAPI({ description: 'Lists all users. <br> This includes their groups and permissions directly granted to them (if existing/associated).' })
+	@OpenAPI({ description: 'Lists all users. <br> This includes their groups and permissions granted to them.' })
 	async getAll() {
 		let responseUsers: ResponseUser[] = new Array<ResponseUser>();
 		const users = await this.userRepository.find({ relations: ['permissions', 'groups', 'groups.permissions'] });
@@ -41,17 +42,30 @@ export class UserController {
 	@ResponseSchema(ResponseUser)
 	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
 	@OnUndefined(UserNotFoundError)
-	@OpenAPI({ description: 'Lists all information about the user whose id got provided. <br> Please remember that only permissions granted directly to the user will show up here, not permissions inherited from groups.' })
+	@OpenAPI({ description: 'Lists all information about the user whose id got provided. <br> Please remember that all permissions granted to the user will show up here.' })
 	async getOne(@Param('id') id: number) {
 		let user = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions'] })
 		if (!user) { throw new UserNotFoundError(); }
 		return new ResponseUser(user);
 	}
 
+	@Get('/:id/permissions')
+	@Authorized("USER:GET")
+	@ResponseSchema(ResponseUser)
+	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@OnUndefined(UserNotFoundError)
+	@OpenAPI({ description: 'Lists all permissions granted to the user sorted into directly granted and inherited as permission response objects.' })
+	async getPermissions(@Param('id') id: number) {
+		let user = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions', 'permissions.principal', 'groups.permissions.principal'] })
+		if (!user) { throw new UserNotFoundError(); }
+		return new ResponseUserPermissions(user);
+	}
+
 	@Post()
 	@Authorized("USER:CREATE")
 	@ResponseSchema(ResponseUser)
-	@ResponseSchema(UserGroupNotFoundError)
+	@ResponseSchema(UserGroupNotFoundError, { statusCode: 404 })
+	@ResponseSchema(UsernameContainsIllegalCharacterError, { statusCode: 406 })
 	@OpenAPI({ description: 'Create a new user. <br> If you want to grant permissions to the user you have to create them seperately by posting to /api/permissions after creating the user.' })
 	async post(@Body({ validate: true }) createUser: CreateUser) {
 		let user;
@@ -62,7 +76,7 @@ export class UserController {
 		}
 
 		user = await this.userRepository.save(user)
-		return new ResponseUser(await this.userRepository.findOne({ id: user.id }, { relations: ['permissions', 'groups'] }));
+		return new ResponseUser(await this.userRepository.findOne({ id: user.id }, { relations: ['permissions', 'groups', 'groups.permissions'] }));
 	}
 
 	@Put('/:id')
@@ -70,6 +84,7 @@ export class UserController {
 	@ResponseSchema(ResponseUser)
 	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
 	@ResponseSchema(UserIdsNotMatchingError, { statusCode: 406 })
+	@ResponseSchema(UsernameContainsIllegalCharacterError, { statusCode: 406 })
 	@OpenAPI({ description: "Update the user whose id you provided. <br> To change the permissions directly granted to the user please use /api/permissions instead. <br> Please remember that ids can't be changed." })
 	async put(@Param('id') id: number, @Body({ validate: true }) updateUser: UpdateUser) {
 		let oldUser = await this.userRepository.findOne({ id: id });
@@ -83,19 +98,21 @@ export class UserController {
 		}
 		await this.userRepository.save(await updateUser.update(oldUser));
 
-		return new ResponseUser(await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups'] }));
+		return new ResponseUser(await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions'] }));
 	}
 
 	@Delete('/:id')
 	@Authorized("USER:DELETE")
 	@ResponseSchema(ResponseUser)
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(UserDeletionNotConfirmedError, { statusCode: 406 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the user whose id you provided. <br> If there are any permissions directly granted to the user they will get deleted as well. <br> If no user with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the user whose id you provided. <br> You have to confirm your decision by providing the ?force=true query param. <br> If there are any permissions directly granted to the user they will get deleted as well. <br> If no user with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		if (!force) { throw new UserDeletionNotConfirmedError; }
 		let user = await this.userRepository.findOne({ id: id });
 		if (!user) { return null; }
-		const responseUser = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups'] });;
+		const responseUser = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions'] });;
 
 		const permissionControler = new PermissionController();
 		for (let permission of responseUser.permissions) {

src/errors/AddressErrors.ts

@@ -1,24 +1,57 @@
 import { IsString } from 'class-validator';
-import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+import { BadRequestError } from 'routing-controllers';
 
 /**
- * Error to throw, when to provided address doesn't belong to the accepted types.
+ * Error to throw when an address's postal code fails validation.
  */
-export class AddressWrongTypeError extends NotAcceptableError {
+export class AddressPostalCodeInvalidError extends BadRequestError {
 	@IsString()
-	name = "AddressWrongTypeError"
+	name = "AddressPostalCodeInvalidError"
 
 	@IsString()
-	message = "The address must be an existing address's id. \n You provided a object of another type."
+	message = "The postal code you provided is invalid. \n Please check if your postal code follows the postal code validation guidelines."
 }
 
 /**
- * Error to throw, when a non-existent address get's loaded.
+ * Error to throw when an non-empty address's first line isn't set.
  */
-export class AddressNotFoundError extends NotFoundError {
+export class AddressFirstLineEmptyError extends BadRequestError {
 	@IsString()
-	name = "AddressNotFoundError"
+	name = "AddressFirstLineEmptyError"
 
 	@IsString()
-	message = "The address you provided couldn't be located in the system. \n Please check your request."
+	message = "You provided a empty first address line. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's postal code isn't set.
+ */
+export class AddressPostalCodeEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressPostalCodeEmptyError"
+
+	@IsString()
+	message = "You provided a empty postal code. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's city isn't set.
+ */
+export class AddressCityEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressCityEmptyError"
+
+	@IsString()
+	message = "You provided a empty city. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's country isn't set.
+ */
+export class AddressCountryEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressCountryEmptyError"
+
+	@IsString()
+	message = "You provided a empty country. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
 }

src/errors/DonationErrors.ts

@@ -0,0 +1,25 @@
+import { IsString } from 'class-validator';
+import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+
+/**
+ * Error to throw when a Donation couldn't be found.
+ */
+export class DonationNotFoundError extends NotFoundError {
+	@IsString()
+	name = "DonationNotFoundError"
+
+	@IsString()
+	message = "Donation not found!"
+}
+
+/**
+ * Error to throw when two Donations' ids don't match.
+ * Usually occurs when a user tries to change a Donation's id.
+ */
+export class DonationIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "DonationIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a Donation's id: This isn't allowed!"
+}

src/errors/DonorErrors.ts

@@ -33,4 +33,15 @@ export class DonorReceiptAddressNeededError extends NotAcceptableError {
 
 	@IsString()
 	message = "An address is needed to create a receipt for a donor. \n You didn't provide one."
+}
+
+/**
+* Error to throw when a donor still has donations associated.
+*/
+export class DonorHasDonationsError extends NotAcceptableError {
+	@IsString()
+	name = "DonorHasDonationsError"
+
+	@IsString()
+	message = "This donor still has donations associated with it. \n If you want to delete this donor with all it's donations and teams add `?force` to your query."
 }

src/errors/GroupContactErrors.ts

@@ -2,18 +2,7 @@ import { IsString } from 'class-validator';
 import { NotAcceptableError, NotFoundError } from 'routing-controllers';
 
 /**
- * Error to throw, when a provided groupContact doesn't belong to the accepted types.
- */
-export class GroupContactWrongTypeError extends NotAcceptableError {
-	@IsString()
-	name = "GroupContactWrongTypeError"
-
-	@IsString()
-	message = "The groupContact must be an existing groupContact's id. \n You provided a object of another type."
-}
-
-/**
- * Error to throw, when a non-existent groupContact get's loaded.
+ * Error to throw, when a non-existent contact get's requested.
  */
 export class GroupContactNotFoundError extends NotFoundError {
 	@IsString()
@@ -21,4 +10,16 @@ export class GroupContactNotFoundError extends NotFoundError {
 
 	@IsString()
 	message = "The groupContact you provided couldn't be located in the system. \n Please check your request."
-}
+}
+
+/**
+ * Error to throw when two contacts' ids don't match.
+ * Usually occurs when a user tries to change a contact's id.
+ */
+export class GroupContactIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "GroupContactIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a contact's id: This isn't allowed!"
+}

src/errors/RunnerErrors.ts

@@ -33,4 +33,15 @@ export class RunnerGroupNeededError extends NotAcceptableError {
 
 	@IsString()
 	message = "Runner's need to be part of one group (team or organisation)! \n You provided neither."
+}
+
+/**
+* Error to throw when a runner still has distance donations associated.
+*/
+export class RunnerHasDistanceDonationsError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerHasDistanceDonationsError"
+
+	@IsString()
+	message = "This runner still has distance donations associated with it. \n If you want to delete this runner with all it's donations and teams add `?force` to your query."
 }

src/errors/UserErrors.ts

@@ -4,7 +4,7 @@ import { NotAcceptableError, NotFoundError } from 'routing-controllers';
 
 /**
  * Error to throw when no username or email is set.
- * We somehow need to identify you :)
+ * We somehow need to identify you on login.
  */
 export class UsernameOrEmailNeededError extends NotFoundError {
 	@IsString()
@@ -14,6 +14,30 @@ export class UsernameOrEmailNeededError extends NotFoundError {
 	message = "No username or email is set!"
 }
 
+/**
+ * Error to throw when no username contains illegal characters.
+ * Right now the only one is "@" but this could change in the future.
+ */
+export class UsernameContainsIllegalCharacterError extends NotAcceptableError {
+	@IsString()
+	name = "UsernameContainsIllegalCharacterError"
+
+	@IsString()
+	message = "The provided username contains illegal characters! \n Right now the following characters are considered illegal: '@'"
+}
+
+/**
+ * Error to throw when no email is set.
+ * We somehow need to identify you :)
+ */
+export class UserEmailNeededError extends NotFoundError {
+	@IsString()
+	name = "UserEmailNeededError"
+
+	@IsString()
+	message = "No email is set! \n You have to provide email addresses for users (used for password reset among others)."
+}
+
 /**
  * Error to throw when a user couldn't be found.
  */
@@ -35,4 +59,16 @@ export class UserIdsNotMatchingError extends NotAcceptableError {
 
 	@IsString()
 	message = "The ids don't match!! \n And if you wanted to change a user's id: This isn't allowed!"
+}
+
+/**
+ * Error to throw when two users' ids don't match.
+ * Usually occurs when a user tries to change a user's id.
+ */
+export class UserDeletionNotConfirmedError extends NotAcceptableError {
+	@IsString()
+	name = "UserDeletionNotConfirmedError"
+
+	@IsString()
+	message = "You are trying to delete a user! \n If you're sure about doing this: provide the ?force=true query param."
 }

src/loaders/openapi.ts

@@ -1,4 +1,4 @@
-import { validationMetadatasToSchemas } from "class-validator-jsonschema";
+import { validationMetadatasToSchemas } from "@odit/class-validator-jsonschema";
 import express, { Application } from "express";
 import path from 'path';
 import { getMetadataArgsStorage } from "routing-controllers";

src/middlewares/UserChecker.ts

@@ -0,0 +1,58 @@
+import cookie from "cookie";
+import * as jwt from "jsonwebtoken";
+import { Action } from 'routing-controllers';
+import { getConnectionManager } from 'typeorm';
+import { config } from '../config';
+import { IllegalJWTError, UserDisabledError, UserNonexistantOrRefreshtokenInvalidError } from '../errors/AuthError';
+import { JwtCreator, JwtUser } from '../jwtcreator';
+import { User } from '../models/entities/User';
+
+/**
+ * TODO:
+ */
+const UserChecker = async (action: Action) => {
+    let jwtPayload = undefined
+    try {
+        let provided_token = "" + action.request.headers["authorization"].replace("Bearer ", "");
+        jwtPayload = <any>jwt.verify(provided_token, config.jwt_secret);
+        jwtPayload = jwtPayload["userdetails"];
+    } catch (error) {
+        jwtPayload = await refresh(action);
+    }
+
+    const user = await getConnectionManager().get().getRepository(User).findOne({ id: jwtPayload["id"], refreshTokenCount: jwtPayload["refreshTokenCount"] })
+    if (!user) { throw new UserNonexistantOrRefreshtokenInvalidError() }
+    if (user.enabled == false) { throw new UserDisabledError(); }
+    return user;
+};
+
+/**
+ * Handles soft-refreshing of access-tokens.
+ * @param action Routing-Controllers action object that provides request and response objects among other stuff.
+ */
+const refresh = async (action: Action) => {
+    let refresh_token = undefined;
+    try {
+        refresh_token = cookie.parse(action.request.headers["cookie"])["lfk_backend__refresh_token"];
+    }
+    catch {
+        throw new IllegalJWTError();
+    }
+
+    let jwtPayload = undefined;
+    try {
+        jwtPayload = <any>jwt.verify(refresh_token, config.jwt_secret);
+    } catch (error) {
+        throw new IllegalJWTError();
+    }
+
+    const user = await getConnectionManager().get().getRepository(User).findOne({ id: jwtPayload["id"], refreshTokenCount: jwtPayload["refreshTokenCount"] }, { relations: ['permissions', 'groups', 'groups.permissions'] })
+    if (!user) { throw new UserNonexistantOrRefreshtokenInvalidError() }
+    if (user.enabled == false) { throw new UserDisabledError(); }
+
+    let newAccess = JwtCreator.createAccess(user);
+    action.response.header("authorization", "Bearer " + newAccess);
+
+    return await new JwtUser(user);
+}
+export default UserChecker;

src/models/actions/create/CreateAddress.ts

@@ -1,70 +0,0 @@
-import { IsNotEmpty, IsOptional, IsPostalCode, IsString } from 'class-validator';
-import { config } from '../../../config';
-import { Address } from '../../entities/Address';
-
-/**
- * This classed is used to create a new Address entity from a json body (post request).
- */
-export class CreateAddress {
-    /**
-     * The newaddress's description.
-     */
-    @IsString()
-    @IsOptional()
-    description?: string;
-
-    /**
-     * The new address's first line.
-     * Containing the street and house number.
-     */
-    @IsString()
-    @IsNotEmpty()
-    address1: string;
-
-    /**
-     * The new address's second line.
-     * Containing optional information.
-     */
-    @IsString()
-    @IsOptional()
-    address2?: string;
-
-    /**
-     * The new address's postal code.
-     * This will get checked against the postal code syntax for the configured country.
-     * TODO: Implement the config option. 
-     */
-    @IsString()
-    @IsNotEmpty()
-    @IsPostalCode(config.postalcode_validation_countrycode)
-    postalcode: string;
-
-    /**
-     * The new address's city.
-     */
-    @IsString()
-    @IsNotEmpty()
-    city: string;
-
-    /**
-     * The new address's country.
-     */
-    @IsString()
-    @IsNotEmpty()
-    country: string;
-
-    /**
-     * Creates a new Address entity from this.
-     */
-    public async toEntity(): Promise<Address> {
-        let newAddress: Address = new Address();
-
-        newAddress.address1 = this.address1;
-        newAddress.address2 = this.address2;
-        newAddress.postalcode = this.postalcode;
-        newAddress.city = this.city;
-        newAddress.country = this.country;
-
-        return newAddress;
-    }
-}

src/models/actions/create/CreateDistanceDonation.ts

@@ -0,0 +1,52 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { DistanceDonation } from '../../entities/DistanceDonation';
+import { Runner } from '../../entities/Runner';
+import { CreateDonation } from './CreateDonation';
+
+/**
+ * This class is used to create a new FixedDonation entity from a json body (post request).
+ */
+export class CreateDistanceDonation extends CreateDonation {
+
+    /**
+     * The donation's associated runner's id.
+     * This is important to link the runner's distance ran to the donation.
+     */
+    @IsInt()
+    @IsPositive()
+    runner: number;
+
+    /**
+     * The donation's amount per distance (full kilometer aka 1000 meters).
+     * The unit is your currency's smallest unit (default: euro cent).
+     */
+    @IsInt()
+    @IsPositive()
+    amountPerDistance: number;
+
+    /**
+     * Creates a new FixedDonation entity from this.
+     */
+    public async toEntity(): Promise<DistanceDonation> {
+        let newDonation = new DistanceDonation;
+
+        newDonation.amountPerDistance = this.amountPerDistance;
+        newDonation.donor = await this.getDonor();
+        newDonation.runner = await this.getRunner();
+
+        return newDonation;
+    }
+
+    /**
+     * Gets a runner based on the runner id provided via this.runner.
+     */
+    public async getRunner(): Promise<Runner> {
+        const runner = await getConnection().getRepository(Runner).findOne({ id: this.runner });
+        if (!runner) {
+            throw new RunnerNotFoundError();
+        }
+        return runner;
+    }
+}

src/models/actions/create/CreateDonation.ts

@@ -0,0 +1,34 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { DonorNotFoundError } from '../../../errors/DonorErrors';
+import { Donation } from '../../entities/Donation';
+import { Donor } from '../../entities/Donor';
+
+/**
+ * This class is used to create a new Donation entity from a json body (post request).
+ */
+export abstract class CreateDonation {
+    /**
+     * The donation's associated donor's id.
+     * This is important to link donations to donors.
+     */
+    @IsInt()
+    @IsPositive()
+    donor: number;
+
+    /**
+     * Creates a new Donation entity from this.
+     */
+    public abstract toEntity(): Promise<Donation>;
+
+    /**
+     * Gets a donor based on the donor id provided via this.donor.
+     */
+    public async getDonor(): Promise<Donor> {
+        const donor = await getConnection().getRepository(Donor).findOne({ id: this.donor });
+        if (!donor) {
+            throw new DonorNotFoundError();
+        }
+        return donor;
+    }
+}

src/models/actions/create/CreateDonor.ts

@@ -1,5 +1,6 @@
 import { IsBoolean, IsOptional } from 'class-validator';
 import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
+import { Address } from '../../entities/Address';
 import { Donor } from '../../entities/Donor';
 import { CreateParticipant } from './CreateParticipant';
 
@@ -26,10 +27,10 @@ export class CreateDonor extends CreateParticipant {
         newDonor.lastname = this.lastname;
         newDonor.phone = this.phone;
         newDonor.email = this.email;
-        newDonor.address = await this.getAddress();
         newDonor.receiptNeeded = this.receiptNeeded;
-
-        if (this.receiptNeeded == true && this.address == null) {
+        newDonor.address = this.address;
+        Address.validate(newDonor.address);
+        if (this.receiptNeeded == true && Address.isValidAddress(newDonor.address) == false) {
             throw new DonorReceiptAddressNeededError()
         }
 

src/models/actions/create/CreateFixedDonation.ts

@@ -0,0 +1,28 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { FixedDonation } from '../../entities/FixedDonation';
+import { CreateDonation } from './CreateDonation';
+
+/**
+ * This class is used to create a new FixedDonation entity from a json body (post request).
+ */
+export class CreateFixedDonation extends CreateDonation {
+    /**
+     * The donation's amount.
+     * The unit is your currency's smallest unit (default: euro cent).
+     */
+    @IsInt()
+    @IsPositive()
+    amount: number;
+
+    /**
+     * Creates a new FixedDonation entity from this.
+     */
+    public async toEntity(): Promise<FixedDonation> {
+        let newDonation = new FixedDonation;
+
+        newDonation.amount = this.amount;
+        newDonation.donor = await this.getDonor();
+
+        return newDonation;
+    }
+}

src/models/actions/create/CreateGroupContact.ts

@@ -1,12 +1,13 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { config } from '../../../config';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
+import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
 import { Address } from '../../entities/Address';
 import { GroupContact } from '../../entities/GroupContact';
+import { RunnerGroup } from '../../entities/RunnerGroup';
 
 /**
- * This classed is used to create a new Group entity from a json body (post request).
+ * This classed is used to create a new GroupContact entity from a json body (post request).
  */
 export class CreateGroupContact {
     /**
@@ -32,11 +33,10 @@ export class CreateGroupContact {
 
     /**
      * The new contact's address.
-     * Must be the address's id.
      */
-    @IsInt()
     @IsOptional()
-    address?: number;
+    @IsObject()
+    address?: Address;
 
     /**
      * The contact's phone number.
@@ -47,39 +47,51 @@ export class CreateGroupContact {
     phone?: string;
 
     /**
-     * The contact's email address.
+     * The new contact's email address.
      */
     @IsOptional()
     @IsEmail()
     email?: string;
 
     /**
-     * Gets the new contact's address by it's id.
+     * The new contacts's groups' ids.
+     * You can provide either one groupId or an array of groupIDs.
      */
-    public async getAddress(): Promise<Address> {
-        if (this.address === undefined || this.address === null) {
-            return null;
-        }
-        if (!isNaN(this.address)) {
-            let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-            if (!address) { throw new AddressNotFoundError; }
-            return address;
-        }
+    @IsOptional()
+    groups?: number[] | number
 
-        throw new AddressWrongTypeError;
+
+    /**
+     * Get's all groups for this contact by their id's;
+     */
+    public async getGroups(): Promise<RunnerGroup[]> {
+        if (!this.groups) { return null; }
+        let groups = new Array<RunnerGroup>();
+        if (!Array.isArray(this.groups)) {
+            this.groups = [this.groups]
+        }
+        for (let group of this.groups) {
+            let found = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: group });
+            if (!found) { throw new RunnerGroupNotFoundError(); }
+            groups.push(found);
+        }
+        return groups;
     }
 
     /**
-     * Creates a new Address entity from this.
+     * Creates a new GroupContact entity from this.
      */
     public async toEntity(): Promise<GroupContact> {
-        let contact: GroupContact = new GroupContact();
-        contact.firstname = this.firstname;
-        contact.middlename = this.middlename;
-        contact.lastname = this.lastname;
-        contact.email = this.email;
-        contact.phone = this.phone;
-        contact.address = await this.getAddress();
-        return null;
+        let newContact: GroupContact = new GroupContact();
+        newContact.firstname = this.firstname;
+        newContact.middlename = this.middlename;
+        newContact.lastname = this.lastname;
+        newContact.email = this.email;
+        newContact.phone = this.phone;
+        newContact.address = this.address;
+        Address.validate(newContact.address);
+        newContact.groups = await this.getGroups();
+
+        return newContact;
     }
 }

src/models/actions/create/CreateParticipant.ts

@@ -1,7 +1,5 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
+import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
 import { config } from '../../../config';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
 import { Address } from '../../entities/Address';
 
 /**
@@ -48,25 +46,8 @@ export abstract class CreateParticipant {
 
     /**
      * The new participant's address.
-     * Must be of type number (address id).
      */
-    @IsInt()
     @IsOptional()
-    address?: number;
-
-    /**
-     * Gets the new participant's address by it's address.
-     */
-    public async getAddress(): Promise<Address> {
-        if (this.address === undefined || this.address === null) {
-            return null;
-        }
-        if (!isNaN(this.address)) {
-            let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-            if (!address) { throw new AddressNotFoundError; }
-            return address;
-        }
-
-        throw new AddressWrongTypeError;
-    }
+    @IsObject()
+    address?: Address;
 }

src/models/actions/create/CreateRunner.ts

@@ -3,6 +3,7 @@ import { getConnectionManager } from 'typeorm';
 import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
 import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { Address } from '../../entities/Address';
 import { Runner } from '../../entities/Runner';
 import { RunnerGroup } from '../../entities/RunnerGroup';
 import { CreateParticipant } from './CreateParticipant';
@@ -30,7 +31,8 @@ export class CreateRunner extends CreateParticipant {
         newRunner.phone = this.phone;
         newRunner.email = this.email;
         newRunner.group = await this.getGroup();
-        newRunner.address = await this.getAddress();
+        newRunner.address = this.address;
+        Address.validate(newRunner.address);
 
         return newRunner;
     }

src/models/actions/create/CreateRunnerCard.ts

@@ -9,7 +9,7 @@ import { RunnerCard } from '../../entities/RunnerCard';
  */
 export class CreateRunnerCard {
     /**
-     * The card's associated runner.
+     * The card's associated runner's id.
      */
     @IsInt()
     @IsOptional()

src/models/actions/create/CreateRunnerGroup.ts

@@ -1,6 +1,6 @@
 import { IsInt, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { GroupContactNotFoundError, GroupContactWrongTypeError } from '../../../errors/GroupContactErrors';
+import { GroupContactNotFoundError } from '../../../errors/GroupContactErrors';
 import { GroupContact } from '../../entities/GroupContact';
 
 /**
@@ -15,7 +15,7 @@ export abstract class CreateRunnerGroup {
     name: string;
 
     /**
-     * The new group's contact.
+     * The new group's contact's id.
      * Optional
      */
     @IsInt()
@@ -26,15 +26,10 @@ export abstract class CreateRunnerGroup {
      * Gets the new group's contact by it's id.
      */
     public async getContact(): Promise<GroupContact> {
-        if (this.contact === undefined || this.contact === null) {
-            return null;
-        }
-        if (!isNaN(this.contact)) {
-            let contact = await getConnectionManager().get().getRepository(GroupContact).findOne({ id: this.contact });
-            if (!contact) { throw new GroupContactNotFoundError; }
-            return contact;
-        }
+        if (!this.contact) { return null; }
+        let contact = await getConnectionManager().get().getRepository(GroupContact).findOne({ id: this.contact });
+        if (!contact) { throw new GroupContactNotFoundError; }
+        return contact;
 
-        throw new GroupContactWrongTypeError;
     }
 }

src/models/actions/create/CreateRunnerOrganisation.ts

@@ -1,6 +1,4 @@
-import { IsInt, IsOptional } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
+import { IsObject, IsOptional } from 'class-validator';
 import { Address } from '../../entities/Address';
 import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
 import { CreateRunnerGroup } from './CreateRunnerGroup';
@@ -11,27 +9,10 @@ import { CreateRunnerGroup } from './CreateRunnerGroup';
 export class CreateRunnerOrganisation extends CreateRunnerGroup {
     /**
      * The new organisation's address.
-     * Must be of type number (address id).
      */
-    @IsInt()
     @IsOptional()
-    address?: number;
-
-    /**
-     * Gets the org's address by it's id.
-     */
-    public async getAddress(): Promise<Address> {
-        if (this.address === undefined || this.address === null) {
-            return null;
-        }
-        if (!isNaN(this.address)) {
-            let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-            if (!address) { throw new AddressNotFoundError; }
-            return address;
-        }
-
-        throw new AddressWrongTypeError;
-    }
+    @IsObject()
+    address?: Address;
 
     /**
      * Creates a new RunnerOrganisation entity from this.
@@ -41,7 +22,8 @@ export class CreateRunnerOrganisation extends CreateRunnerGroup {
 
         newRunnerOrganisation.name = this.name;
         newRunnerOrganisation.contact = await this.getContact();
-        // newRunnerOrganisation.address = await this.getAddress();
+        newRunnerOrganisation.address = this.address;
+        Address.validate(newRunnerOrganisation.address);
 
         return newRunnerOrganisation;
     }

src/models/actions/create/CreateRunnerTeam.ts

@@ -1,6 +1,6 @@
 import { IsInt, IsNotEmpty } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerOrganisationNotFoundError } from '../../../errors/RunnerOrganisationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
 import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
 import { RunnerTeam } from '../../entities/RunnerTeam';
@@ -12,7 +12,7 @@ import { CreateRunnerGroup } from './CreateRunnerGroup';
 export class CreateRunnerTeam extends CreateRunnerGroup {
 
     /**
-     * The new team's parent group (organisation).
+     * The new team's parent org's id.
      */
     @IsInt()
     @IsNotEmpty()
@@ -25,13 +25,9 @@ export class CreateRunnerTeam extends CreateRunnerGroup {
         if (this.parentGroup === undefined || this.parentGroup === null) {
             throw new RunnerTeamNeedsParentError();
         }
-        if (!isNaN(this.parentGroup)) {
-            let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup });
-            if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
-            return parentGroup;
-        }
-
-        throw new RunnerOrganisationWrongTypeError;
+        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup });
+        if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
+        return parentGroup;
     }
 
     /**
@@ -42,7 +38,6 @@ export class CreateRunnerTeam extends CreateRunnerGroup {
 
         newRunnerTeam.name = this.name;
         newRunnerTeam.parentGroup = await this.getParent();
-
         newRunnerTeam.contact = await this.getContact()
 
         return newRunnerTeam;

src/models/actions/create/CreateScan.ts

@@ -9,7 +9,7 @@ import { Scan } from '../../entities/Scan';
  */
 export abstract class CreateScan {
     /**
-     * The scan's associated runner.
+     * The scan's associated runner's id.
      * This is important to link ran distances to runners.
      */
     @IsInt()

src/models/actions/create/CreateScanStation.ts

@@ -19,7 +19,7 @@ export class CreateScanStation {
     description?: string;
 
     /**
-     * The station's associated track.
+     * The station's associated track's id.
      */
     @IsInt()
     @IsPositive()

src/models/actions/create/CreateTrackScan.ts

@@ -12,7 +12,7 @@ import { TrackScan } from '../../entities/TrackScan';
  */
 export class CreateTrackScan {
     /**
-     * The runnerCard associated with the scan.
+     * The id of the runnerCard associated with the scan.
      * This get's saved for documentation and management purposes.
      */
     @IsInt()
@@ -20,8 +20,8 @@ export class CreateTrackScan {
     card: number;
 
     /**
-     * The scanning station that created the scan.
-     * Mainly used for logging and traceing back scans (or errors)
+     * The scanning station's id that created the scan.
+     * Mainly used for logging and traceing back scans (or errors).
      */
     @IsInt()
     @IsPositive()

src/models/actions/create/CreateUser.ts

@@ -1,9 +1,9 @@
 import * as argon2 from "argon2";
-import { IsBoolean, IsEmail, IsOptional, IsPhoneNumber, IsString, IsUrl } from 'class-validator';
+import { IsBoolean, IsEmail, IsNotEmpty, IsOptional, IsPhoneNumber, IsString, IsUrl } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import * as uuid from 'uuid';
 import { config } from '../../../config';
-import { UsernameOrEmailNeededError } from '../../../errors/UserErrors';
+import { UserEmailNeededError, UsernameContainsIllegalCharacterError } from '../../../errors/UserErrors';
 import { UserGroupNotFoundError } from '../../../errors/UserGroupErrors';
 import { User } from '../../entities/User';
 import { UserGroup } from '../../entities/UserGroup';
@@ -33,7 +33,7 @@ export class CreateUser {
 
     /**
      * The new user's username.
-     * You have to provide at least one of: {email, username}.
+     * You have to provide a email addres, so this is optional.
      */
     @IsOptional()
     @IsString()
@@ -41,12 +41,11 @@ export class CreateUser {
 
     /**
      * The new user's email address.
-     * You have to provide at least one of: {email, username}.
      */
     @IsEmail()
     @IsString()
-    @IsOptional()
-    email?: string;
+    @IsNotEmpty()
+    email: string;
 
     /**
      * The new user's phone number.
@@ -72,7 +71,7 @@ export class CreateUser {
     enabled?: boolean = true;
 
     /**
-     * The new user's groups' id(s).
+     * The new user's groups' ids.
      * You can provide either one groupId or an array of groupIDs.
      */
     @IsOptional()
@@ -92,9 +91,10 @@ export class CreateUser {
     public async toEntity(): Promise<User> {
         let newUser: User = new User();
 
-        if (this.email === undefined && this.username === undefined) {
-            throw new UsernameOrEmailNeededError();
+        if (!this.email) {
+            throw new UserEmailNeededError();
         }
+        if (this.username.includes("@")) { throw new UsernameContainsIllegalCharacterError(); }
 
         newUser.email = this.email
         newUser.username = this.username

src/models/actions/update/UpdateDistanceDonation.ts

@@ -0,0 +1,51 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { DistanceDonation } from '../../entities/DistanceDonation';
+import { Runner } from '../../entities/Runner';
+import { UpdateDonation } from './UpdateDonation';
+
+/**
+ * This class is used to update a DistanceDonation entity (via put request).
+ */
+export class UpdateDistanceDonation extends UpdateDonation {
+
+    /**
+     * The donation's associated runner's id.
+     * This is important to link the runner's distance ran to the donation.
+     */
+    @IsInt()
+    @IsPositive()
+    runner: number;
+
+    /**
+     * The donation's amount per distance (full kilometer aka 1000 meters).
+     * The unit is your currency's smallest unit (default: euro cent).
+     */
+    @IsInt()
+    @IsPositive()
+    amountPerDistance: number;
+
+    /**
+     * Update a DistanceDonation entity based on this.
+     * @param donation The donation that shall be updated.
+     */
+    public async update(donation: DistanceDonation): Promise<DistanceDonation> {
+        donation.amountPerDistance = this.amountPerDistance;
+        donation.donor = await this.getDonor();
+        donation.runner = await this.getRunner();
+
+        return donation;
+    }
+
+    /**
+     * Gets a runner based on the runner id provided via this.runner.
+     */
+    public async getRunner(): Promise<Runner> {
+        const runner = await getConnection().getRepository(Runner).findOne({ id: this.runner });
+        if (!runner) {
+            throw new RunnerNotFoundError();
+        }
+        return runner;
+    }
+}

src/models/actions/update/UpdateDonation.ts

@@ -0,0 +1,41 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { DonorNotFoundError } from '../../../errors/DonorErrors';
+import { Donation } from '../../entities/Donation';
+import { Donor } from '../../entities/Donor';
+
+/**
+ * This class is used to update a Donation entity (via put request).
+ */
+export abstract class UpdateDonation {
+    /**
+     * The updated donation's id.
+     * This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to).
+     */
+    @IsInt()
+    id: number;
+
+    /**
+     * The updated donation's associated donor's id.
+     * This is important to link donations to donors.
+     */
+    @IsInt()
+    @IsPositive()
+    donor: number;
+
+    /**
+     * Creates a new Donation entity from this.
+     */
+    public abstract update(donation: Donation): Promise<Donation>;
+
+    /**
+     * Gets a donor based on the donor id provided via this.donor.
+     */
+    public async getDonor(): Promise<Donor> {
+        const donor = await getConnection().getRepository(Donor).findOne({ id: this.donor });
+        if (!donor) {
+            throw new DonorNotFoundError();
+        }
+        return donor;
+    }
+}

src/models/actions/update/UpdateDonor.ts

@@ -1,5 +1,6 @@
 import { IsBoolean, IsInt, IsOptional } from 'class-validator';
 import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
+import { Address } from '../../entities/Address';
 import { Donor } from '../../entities/Donor';
 import { CreateParticipant } from '../create/CreateParticipant';
 
@@ -33,9 +34,10 @@ export class UpdateDonor extends CreateParticipant {
         donor.phone = this.phone;
         donor.email = this.email;
         donor.receiptNeeded = this.receiptNeeded;
-        donor.address = await this.getAddress();
-
-        if (this.receiptNeeded == true && this.address == null) {
+        if (!this.address) { donor.address.reset(); }
+        else { donor.address = this.address; }
+        Address.validate(donor.address);
+        if (this.receiptNeeded == true && Address.isValidAddress(donor.address) == false) {
             throw new DonorReceiptAddressNeededError()
         }
 

src/models/actions/update/UpdateFixedDonation.ts

@@ -0,0 +1,27 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { FixedDonation } from '../../entities/FixedDonation';
+import { UpdateDonation } from './UpdateDonation';
+
+/**
+ * This class is used to update a FixedDonation entity (via put request).
+ */
+export class UpdateFixedDonation extends UpdateDonation {
+    /**
+     * The updated donation's amount.
+     * The unit is your currency's smallest unit (default: euro cent).
+     */
+    @IsInt()
+    @IsPositive()
+    amount: number;
+
+    /**
+     * Update a FixedDonation entity based on this.
+     * @param donation The donation that shall be updated.
+     */
+    public async update(donation: FixedDonation): Promise<FixedDonation> {
+        donation.amount = this.amount;
+        donation.donor = await this.getDonor();
+
+        return donation;
+    }
+}

src/models/actions/update/UpdateGroupContact.ts

@@ -0,0 +1,106 @@
+import { IsEmail, IsInt, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { getConnectionManager } from 'typeorm';
+import { config } from '../../../config';
+import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
+import { Address } from '../../entities/Address';
+import { GroupContact } from '../../entities/GroupContact';
+import { RunnerGroup } from '../../entities/RunnerGroup';
+
+
+/**
+ * This class is used to update a GroupContact entity (via put request).
+ */
+export class UpdateGroupContact {
+    /**
+     * The updated contact's id.
+     * This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to).
+     */
+    @IsInt()
+    id: number;
+
+    /**
+     * The updated contact's first name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    firstname: string;
+
+    /**
+     * The updated contact's middle name.
+     */
+    @IsOptional()
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The updated contact's last name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    lastname: string;
+
+    /**
+     * The updated contact's address.
+     */
+    @IsOptional()
+    @IsObject()
+    address?: Address;
+
+    /**
+     * The updated contact's phone number.
+     * This will be validated against the configured country phone numer syntax (default: international).
+     */
+    @IsOptional()
+    @IsPhoneNumber(config.phone_validation_countrycode)
+    phone?: string;
+
+    /**
+     * The updated contact's email address.
+     */
+    @IsOptional()
+    @IsEmail()
+    email?: string;
+
+    /**
+     * The updated contacts's groups' ids.
+     * You can provide either one groupId or an array of groupIDs.
+     */
+    @IsOptional()
+    groups?: number[] | number
+
+
+    /**
+     * Get's all groups for this contact by their id's;
+     */
+    public async getGroups(): Promise<RunnerGroup[]> {
+        if (!this.groups) { return null; }
+        let groups = new Array<RunnerGroup>();
+        if (!Array.isArray(this.groups)) {
+            this.groups = [this.groups]
+        }
+        for (let group of this.groups) {
+            let found = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: group });
+            if (!found) { throw new RunnerGroupNotFoundError(); }
+            groups.push(found);
+        }
+        return groups;
+    }
+
+    /**
+     * Updates a provided Donor entity based on this.
+     * @param contact the contact you want to update.
+     */
+    public async update(contact: GroupContact): Promise<GroupContact> {
+        contact.firstname = this.firstname; GroupContact
+        contact.middlename = this.middlename;
+        contact.lastname = this.lastname;
+        contact.phone = this.phone;
+        contact.email = this.email;
+        if (!this.address) { contact.address.reset(); }
+        else { contact.address = this.address; }
+        Address.validate(contact.address);
+        contact.groups = await this.getGroups();
+
+        return contact;
+    }
+}

src/models/actions/update/UpdatePermission.ts

@@ -1,7 +1,7 @@
-import { IsInt, IsNotEmpty, IsObject } from 'class-validator';
+import { IsInt, IsNotEmpty, IsPositive } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { PermissionNeedsPrincipalError } from '../../../errors/PermissionErrors';
-import { PrincipalNotFoundError, PrincipalWrongTypeError } from '../../../errors/PrincipalErrors';
+import { PrincipalNotFoundError } from '../../../errors/PrincipalErrors';
 import { Permission } from '../../entities/Permission';
 import { Principal } from '../../entities/Principal';
 import { PermissionAction } from '../../enums/PermissionAction';
@@ -20,12 +20,11 @@ export class UpdatePermission {
     id: number;
 
     /**
-     * The updated permissions's principal.
-     * Just has to contain the principal's id -everything else won't be checked or changed.
+     * The updated permissions's principal's id.
      */
-    @IsObject()
-    @IsNotEmpty()
-    principal: Principal;
+    @IsInt()
+    @IsPositive()
+    principal: number;
 
     /**
      * The permissions's target.
@@ -57,12 +56,8 @@ export class UpdatePermission {
         if (this.principal === undefined || this.principal === null) {
             throw new PermissionNeedsPrincipalError();
         }
-        if (!isNaN(this.principal.id)) {
-            let principal = await getConnectionManager().get().getRepository(Principal).findOne({ id: this.principal.id });
-            if (!principal) { throw new PrincipalNotFoundError(); }
-            return principal;
-        }
-
-        throw new PrincipalWrongTypeError();
+        let principal = await getConnectionManager().get().getRepository(Principal).findOne({ id: this.principal });
+        if (!principal) { throw new PrincipalNotFoundError(); }
+        return principal;
     }
 }

src/models/actions/update/UpdateRunner.ts

@@ -1,8 +1,8 @@
-import { IsInt, IsObject } from 'class-validator';
+import { IsInt, IsPositive } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
-import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { Address } from '../../entities/Address';
 import { Runner } from '../../entities/Runner';
 import { RunnerGroup } from '../../entities/RunnerGroup';
 import { CreateParticipant } from '../create/CreateParticipant';
@@ -20,11 +20,11 @@ export class UpdateRunner extends CreateParticipant {
     id: number;
 
     /**
-     * The updated runner's new team/org.
-     * Just has to contain the group's id -everything else won't be checked or changed.
+     * The updated runner's group's id.
      */
-    @IsObject()
-    group: RunnerGroup;
+    @IsInt()
+    @IsPositive()
+    group: number;
 
     /**
      * Updates a provided Runner entity based on this.
@@ -36,7 +36,9 @@ export class UpdateRunner extends CreateParticipant {
         runner.phone = this.phone;
         runner.email = this.email;
         runner.group = await this.getGroup();
-        runner.address = await this.getAddress();
+        if (!this.address) { runner.address.reset(); }
+        else { runner.address = this.address; }
+        Address.validate(runner.address);
 
         return runner;
     }
@@ -48,12 +50,8 @@ export class UpdateRunner extends CreateParticipant {
         if (this.group === undefined || this.group === null) {
             throw new RunnerTeamNeedsParentError();
         }
-        if (!isNaN(this.group.id)) {
-            let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group.id });
-            if (!group) { throw new RunnerGroupNotFoundError; }
-            return group;
-        }
-
-        throw new RunnerOrganisationWrongTypeError;
+        let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group });
+        if (!group) { throw new RunnerGroupNotFoundError; }
+        return group;
     }
 }

src/models/actions/update/UpdateRunnerCard.ts

@@ -17,7 +17,7 @@ export class UpdateRunnerCard {
     id?: number;
 
     /**
-     * The updated card's associated runner.
+     * The updated card's associated runner's id.
      */
     @IsInt()
     @IsOptional()

src/models/actions/update/UpdateRunnerOrganisation.ts

@@ -1,6 +1,4 @@
-import { IsInt, IsOptional } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
-import { AddressNotFoundError } from '../../../errors/AddressErrors';
+import { IsInt, IsObject, IsOptional } from 'class-validator';
 import { Address } from '../../entities/Address';
 import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
 import { CreateRunnerGroup } from '../create/CreateRunnerGroup';
@@ -19,25 +17,11 @@ export class UpdateRunnerOrganisation extends CreateRunnerGroup {
 
     /**
      * The updated organisation's address.
-     * Just has to contain the address's id - everything else won't be checked or changed.
-     * Optional.
      */
-    @IsInt()
     @IsOptional()
+    @IsObject()
     address?: Address;
 
-    /**
-     * Loads the organisation's address based on it's id.
-     */
-    public async getAddress(): Promise<Address> {
-        if (this.address === undefined || this.address === null) {
-            return null;
-        }
-        let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address.id });
-        if (!address) { throw new AddressNotFoundError; }
-        return address;
-    }
-
     /**
      * Updates a provided RunnerOrganisation entity based on this.
      */
@@ -45,7 +29,9 @@ export class UpdateRunnerOrganisation extends CreateRunnerGroup {
 
         organisation.name = this.name;
         organisation.contact = await this.getContact();
-        // organisation.address = await this.getAddress();
+        if (!this.address) { organisation.address.reset(); }
+        else { organisation.address = this.address; }
+        Address.validate(organisation.address);
 
         return organisation;
     }

src/models/actions/update/UpdateRunnerTeam.ts

@@ -1,6 +1,6 @@
-import { IsInt, IsNotEmpty, IsObject } from 'class-validator';
+import { IsInt, IsPositive } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerOrganisationNotFoundError } from '../../../errors/RunnerOrganisationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
 import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
 import { RunnerTeam } from '../../entities/RunnerTeam';
@@ -19,12 +19,11 @@ export class UpdateRunnerTeam extends CreateRunnerGroup {
     id: number;
 
     /**
-     * The updated team's parentGroup.
-     * Just has to contain the organisation's id - everything else won't be checked or changed.
+     * The updated team's parentGroup's id.
      */
-    @IsObject()
-    @IsNotEmpty()
-    parentGroup: RunnerOrganisation;
+    @IsInt()
+    @IsPositive()
+    parentGroup: number;
 
     /**
      * Loads the updated teams's parentGroup based on it's id.
@@ -33,13 +32,9 @@ export class UpdateRunnerTeam extends CreateRunnerGroup {
         if (this.parentGroup === undefined || this.parentGroup === null) {
             throw new RunnerTeamNeedsParentError();
         }
-        if (!isNaN(this.parentGroup.id)) {
-            let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup.id });
-            if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
-            return parentGroup;
-        }
-
-        throw new RunnerOrganisationWrongTypeError;
+        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup });
+        if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
+        return parentGroup;
     }
 
     /**

src/models/actions/update/UpdateScan.ts

@@ -16,7 +16,7 @@ export abstract class UpdateScan {
     id: number;
 
     /**
-     * The updated scan's associated runner.
+     * The updated scan's associated runner's id.
      * This is important to link ran distances to runners.
      */
     @IsInt()

src/models/actions/update/UpdateTrackScan.ts

@@ -1,4 +1,4 @@
-import { IsBoolean, IsInt, IsOptional } from 'class-validator';
+import { IsBoolean, IsInt, IsOptional, IsPositive } from 'class-validator';
 import { getConnection } from 'typeorm';
 import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
 import { ScanStationNotFoundError } from '../../../errors/ScanStationErrors';
@@ -18,12 +18,12 @@ export abstract class UpdateTrackScan {
     id: number;
 
     /**
-     * The updated scan's associated runner.
+     * The updated scan's associated runner's id.
      * This is important to link ran distances to runners.
      */
     @IsInt()
-    @IsOptional()
-    runner?: number;
+    @IsPositive()
+    runner: number;
 
     /**
      * Is the updated scan valid (for fraud reasons).
@@ -33,12 +33,12 @@ export abstract class UpdateTrackScan {
     valid?: boolean = true;
 
     /**
-     * The updated scan's associated station.
+     * The updated scan's associated station's id.
      * This is important to link ran distances to runners.
      */
     @IsInt()
-    @IsOptional()
-    public station?: number;
+    @IsPositive()
+    public station: number;
 
     /**
      * Update a TrackScan entity based on this.
@@ -46,12 +46,8 @@ export abstract class UpdateTrackScan {
      */
     public async update(scan: TrackScan): Promise<TrackScan> {
         scan.valid = this.valid;
-        if (this.runner) {
-            scan.runner = await this.getRunner();
-        }
-        if (this.station) {
-            scan.station = await this.getStation();
-        }
+        scan.runner = await this.getRunner();
+        scan.station = await this.getStation();
         scan.track = scan.station.track;
 
         return scan;
@@ -72,7 +68,7 @@ export abstract class UpdateTrackScan {
      * Gets a runner based on the runner id provided via this.runner.
      */
     public async getStation(): Promise<ScanStation> {
-        const station = await getConnection().getRepository(ScanStation).findOne({ id: this.station });
+        const station = await getConnection().getRepository(ScanStation).findOne({ id: this.station }, { relations: ['track'] });
         if (!station) {
             throw new ScanStationNotFoundError();
         }

src/models/actions/update/UpdateUser.ts

@@ -1,8 +1,8 @@
 import * as argon2 from "argon2";
-import { IsBoolean, IsEmail, IsInt, IsOptional, IsPhoneNumber, IsString, IsUrl } from 'class-validator';
+import { IsBoolean, IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString, IsUrl } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { config } from '../../../config';
-import { UsernameOrEmailNeededError } from '../../../errors/AuthError';
+import { UserEmailNeededError, UsernameContainsIllegalCharacterError } from '../../../errors/UserErrors';
 import { UserGroupNotFoundError } from '../../../errors/UserGroupErrors';
 import { User } from '../../entities/User';
 import { UserGroup } from '../../entities/UserGroup';
@@ -40,7 +40,7 @@ export class UpdateUser {
 
     /**
      * The updated user's username.
-     * You have to provide at least one of: {email, username}.
+     * You have to provide a email addres, so this is optional.
      */
     @IsOptional()
     @IsString()
@@ -48,12 +48,11 @@ export class UpdateUser {
 
     /**
      * The updated user's email address.
-     * You have to provide at least one of: {email, username}.
      */
     @IsEmail()
     @IsString()
-    @IsOptional()
-    email?: string;
+    @IsNotEmpty()
+    email: string;
 
     /**
      * The updated user's phone number.
@@ -77,14 +76,14 @@ export class UpdateUser {
      * Should the user be enabled?
      */
     @IsBoolean()
+    @IsOptional()
     enabled: boolean = true;
 
     /**
-     * The updated user's groups.
-     * This just has to contain the group's id - everything else won't be changed.
+     * The updated user's groups' ids.
      */
     @IsOptional()
-    groups?: UserGroup[]
+    groups?: number | number[]
 
     /**
     * The user's profile pic (or rather a url pointing to it).
@@ -99,16 +98,18 @@ export class UpdateUser {
      * @param user The user that shall be updated.
      */
     public async update(user: User): Promise<User> {
-        user.email = this.email;
-        user.username = this.username;
-        if ((user.email === undefined || user.email === null) && (user.username === undefined || user.username === null)) {
-            throw new UsernameOrEmailNeededError();
+        if (!this.email) {
+            throw new UserEmailNeededError();
         }
+        if (this.username.includes("@")) { throw new UsernameContainsIllegalCharacterError(); }
+
         if (this.password) {
             user.password = await argon2.hash(this.password + user.uuid);
             user.refreshTokenCount = user.refreshTokenCount + 1;
         }
 
+        user.email = this.email;
+        user.username = this.username;
         user.enabled = this.enabled;
         user.firstname = this.firstname
         user.middlename = this.middlename
@@ -123,7 +124,7 @@ export class UpdateUser {
     }
 
     /**
-     * Loads the updated user's groups based on their ids.
+     * Get's all groups for this user by their id's;
      */
     public async getGroups() {
         if (!this.groups) { return null; }
@@ -132,7 +133,7 @@ export class UpdateUser {
             this.groups = [this.groups]
         }
         for (let group of this.groups) {
-            let found = await getConnectionManager().get().getRepository(UserGroup).findOne({ id: group.id });
+            let found = await getConnectionManager().get().getRepository(UserGroup).findOne({ id: group });
             if (!found) { throw new UserGroupNotFoundError(); }
             groups.push(found);
         }

src/models/entities/Address.ts

@@ -1,44 +1,24 @@
 import {
-  IsInt,
-  IsNotEmpty,
-  IsOptional,
   IsPostalCode,
   IsString
 } from "class-validator";
-import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { Column } from "typeorm";
+import ValidatorJS from 'validator';
 import { config } from '../../config';
-import { IAddressUser } from './IAddressUser';
+import { AddressCityEmptyError, AddressCountryEmptyError, AddressFirstLineEmptyError, AddressPostalCodeEmptyError, AddressPostalCodeInvalidError } from '../../errors/AddressErrors';
 
 /**
- * Defines the Address entity.
+ * Defines the Address class.
  * Implemented this way to prevent any formatting differences.
 */
-@Entity()
 export class Address {
-  /**
-   * Autogenerated unique id (primary key).
-   */
-  @PrimaryGeneratedColumn()
-  @IsInt()
-  id: number;
-
-  /**
-   * The address's description.
-   * Optional and mostly for UX.
-   */
-  @Column({ nullable: true })
-  @IsString()
-  @IsOptional()
-  description?: string;
-
   /**
    * The address's first line.
    * Containing the street and house number.
    */
-  @Column()
+  @Column({ nullable: true })
   @IsString()
-  @IsNotEmpty()
-  address1: string;
+  address1?: string;
 
   /**
    * The address's second line.
@@ -46,45 +26,61 @@ export class Address {
    */
   @Column({ nullable: true })
   @IsString()
-  @IsOptional()
   address2?: string;
 
   /**
    * The address's postal code.
    * This will get checked against the postal code syntax for the configured country.
    */
-  @Column()
+  @Column({ nullable: true })
   @IsString()
-  @IsNotEmpty()
   @IsPostalCode(config.postalcode_validation_countrycode)
   postalcode: string;
 
   /**
    * The address's city.
    */
-  @Column()
+  @Column({ nullable: true })
   @IsString()
-  @IsNotEmpty()
   city: string;
 
   /**
    * The address's country.
    */
-  @Column()
+  @Column({ nullable: true })
   @IsString()
-  @IsNotEmpty()
   country: string;
 
-  /**
-   * Used to link the address to participants.
-   */
-  @OneToMany(() => IAddressUser, addressUser => addressUser.address, { nullable: true })
-  addressUsers: IAddressUser[];
+  public reset() {
+    this.address1 = null;
+    this.address2 = null;
+    this.city = null;
+    this.country = null;
+    this.postalcode = null;
+  }
 
   /**
-   * Turns this entity into it's response class.
+   * Checks if this is a valid address
    */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public static isValidAddress(address: Address): Boolean {
+    if (address == null) { return false; }
+    if (address.address1 == null || address.city == null || address.country == null || address.postalcode == null) { return false; }
+    if (ValidatorJS.isPostalCode(address.postalcode, config.postalcode_validation_countrycode) == false) { return false; }
+    return true;
+  }
+
+  /**
+   * This function validates addresses.
+   * This is a workaround for non-existant class validation for embedded entities.
+   * @param address The address that shall get validated.
+   */
+  public static validate(address: Address) {
+    if (address == null) { return; }
+    if (address.address1 == null && address.city == null && address.country == null && address.postalcode == null) { return; }
+    if (address.address1 == null) { throw new AddressFirstLineEmptyError(); }
+    if (address.postalcode == null) { throw new AddressPostalCodeEmptyError(); }
+    if (address.city == null) { throw new AddressCityEmptyError(); }
+    if (address.country == null) { throw new AddressCountryEmptyError(); }
+    if (ValidatorJS.isPostalCode(address.postalcode.toString(), config.postalcode_validation_countrycode) == false) { throw new AddressPostalCodeInvalidError(); }
   }
 }

src/models/entities/DistanceDonation.ts

@@ -1,5 +1,6 @@
 import { IsInt, IsNotEmpty, IsPositive } from "class-validator";
 import { ChildEntity, Column, ManyToOne } from "typeorm";
+import { ResponseDistanceDonation } from '../responses/ResponseDistanceDonation';
 import { Donation } from "./Donation";
 import { Runner } from "./Runner";
 
@@ -31,7 +32,7 @@ export class DistanceDonation extends Donation {
    * Get's calculated from the runner's distance ran and the amount donated per kilometer.
    */
   public get amount(): number {
-    let calculatedAmount = -1;
+    let calculatedAmount = 0;
     try {
       calculatedAmount = this.amountPerDistance * (this.runner.distance / 1000);
     } catch (error) {
@@ -43,7 +44,7 @@ export class DistanceDonation extends Donation {
   /**
    * Turns this entity into it's response class.
    */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public toResponse(): ResponseDistanceDonation {
+    return new ResponseDistanceDonation(this);
   }
 }

src/models/entities/Donation.ts

@@ -3,6 +3,7 @@ import {
   IsNotEmpty
 } from "class-validator";
 import { Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
+import { ResponseDonation } from '../responses/ResponseDonation';
 import { Donor } from './Donor';
 
 /**
@@ -31,12 +32,13 @@ export abstract class Donation {
    * The donation's amount in cents (or whatever your currency's smallest unit is.).
    * The exact implementation may differ for each type of donation.
    */
-  abstract amount: number;
+  public abstract get amount(): number;
+
 
   /**
    * Turns this entity into it's response class.
    */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public toResponse(): ResponseDonation {
+    return new ResponseDonation(this);
   }
 }

src/models/entities/Donor.ts

@@ -1,4 +1,4 @@
-import { IsBoolean } from "class-validator";
+import { IsBoolean, IsInt } from "class-validator";
 import { ChildEntity, Column, OneToMany } from "typeorm";
 import { ResponseDonor } from '../responses/ResponseDonor';
 import { Donation } from './Donation';
@@ -24,6 +24,15 @@ export class Donor extends Participant {
   @OneToMany(() => Donation, donation => donation.donor, { nullable: true })
   donations: Donation[];
 
+  /**
+   * Returns the total donations of a donor based on his linked donations.
+  */
+  @IsInt()
+  public get donationAmount(): number {
+    if (!this.donations) { return 0; }
+    return this.donations.reduce((sum, current) => sum + current.amount, 0);
+  }
+
   /**
    * Turns this entity into it's response class.
    */

src/models/entities/FixedDonation.ts

@@ -1,5 +1,6 @@
 import { IsInt, IsPositive } from "class-validator";
 import { ChildEntity, Column } from "typeorm";
+import { ResponseDonation } from '../responses/ResponseDonation';
 import { Donation } from "./Donation";
 
 /**
@@ -11,16 +12,33 @@ export class FixedDonation extends Donation {
 
   /**
    * The donation's amount in cents (or whatever your currency's smallest unit is.).
+   * This is the "real" value used by fixed donations.
    */
   @Column()
   @IsInt()
   @IsPositive()
-  amount: number;
+  private _amount: number;
+
+  /**
+   * The donation's amount in cents (or whatever your currency's smallest unit is.).
+   */
+  @IsInt()
+  @IsPositive()
+  public get amount(): number {
+    return this._amount;
+  }
+
+  /**
+   * The donation's amount in cents (or whatever your currency's smallest unit is.).
+   */
+  public set amount(value: number) {
+    this._amount = value;
+  }
 
   /**
    * Turns this entity into it's response class.
    */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public toResponse(): ResponseDonation {
+    return new ResponseDonation(this);
   }
 }

src/models/entities/GroupContact.ts

@@ -7,10 +7,10 @@ import {
 
   IsString
 } from "class-validator";
-import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
 import { config } from '../../config';
+import { ResponseGroupContact } from '../responses/ResponseGroupContact';
 import { Address } from "./Address";
-import { IAddressUser } from './IAddressUser';
 import { RunnerGroup } from "./RunnerGroup";
 
 /**
@@ -18,7 +18,7 @@ import { RunnerGroup } from "./RunnerGroup";
  * Mainly it's own class to reduce duplicate code and enable contact's to be associated with multiple groups.
 */
 @Entity()
-export class GroupContact implements IAddressUser {
+export class GroupContact {
   /**
    * Autogenerated unique id (primary key).
    */
@@ -54,8 +54,7 @@ export class GroupContact implements IAddressUser {
    * The contact's address.
    * This is a address object to prevent any formatting differences.
    */
-  @IsOptional()
-  @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
+  @Column(type => Address)
   address?: Address;
 
   /**
@@ -85,7 +84,7 @@ export class GroupContact implements IAddressUser {
   /**
    * Turns this entity into it's response class.
    */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public toResponse(): ResponseGroupContact {
+    return new ResponseGroupContact(this);
   }
 }

src/models/entities/IAddressUser.ts

@@ -1,20 +0,0 @@
-import { Entity, ManyToOne, PrimaryColumn } from 'typeorm';
-import { Address } from './Address';
-
-/**
- * The interface(tm) all entities using addresses have to implement.
- * This is a abstract class, because apparently typeorm can't really work with interfaces :/
- */
-@Entity()
-export abstract class IAddressUser {
-    @PrimaryColumn()
-    id: number;
-
-    @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
-    address?: Address
-
-    /**
-   * Turns this entity into it's response class.
-   */
-    public abstract toResponse();
-}

src/models/entities/Participant.ts

@@ -7,11 +7,10 @@ import {
 
   IsString
 } from "class-validator";
-import { Column, Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
+import { Column, Entity, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
 import { config } from '../../config';
 import { ResponseParticipant } from '../responses/ResponseParticipant';
 import { Address } from "./Address";
-import { IAddressUser } from './IAddressUser';
 
 /**
  * Defines the Participant entity.
@@ -19,7 +18,7 @@ import { IAddressUser } from './IAddressUser';
 */
 @Entity()
 @TableInheritance({ column: { name: "type", type: "varchar" } })
-export abstract class Participant implements IAddressUser {
+export abstract class Participant {
   /**
    * Autogenerated unique id (primary key).
    */
@@ -55,7 +54,7 @@ export abstract class Participant implements IAddressUser {
    * The participant's address.
    * This is a address object to prevent any formatting differences.
    */
-  @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
+  @Column(type => Address)
   address?: Address;
 
   /**

src/models/entities/RunnerOrganisation.ts

@@ -1,8 +1,7 @@
 import { IsInt, IsOptional } from "class-validator";
-import { ChildEntity, ManyToOne, OneToMany } from "typeorm";
+import { ChildEntity, Column, OneToMany } from "typeorm";
 import { ResponseRunnerOrganisation } from '../responses/ResponseRunnerOrganisation';
 import { Address } from './Address';
-import { IAddressUser } from './IAddressUser';
 import { Runner } from './Runner';
 import { RunnerGroup } from "./RunnerGroup";
 import { RunnerTeam } from "./RunnerTeam";
@@ -12,13 +11,13 @@ import { RunnerTeam } from "./RunnerTeam";
  * This usually is a school, club or company.
 */
 @ChildEntity()
-export class RunnerOrganisation extends RunnerGroup implements IAddressUser {
+export class RunnerOrganisation extends RunnerGroup {
 
   /**
    * The organisations's address.
    */
   @IsOptional()
-  @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
+  @Column(type => Address)
   address?: Address;
 
   /**

src/models/entities/User.ts

@@ -3,6 +3,7 @@ import { ChildEntity, Column, JoinTable, ManyToMany, OneToMany } from "typeorm";
 import { config } from '../../config';
 import { ResponsePrincipal } from '../responses/ResponsePrincipal';
 import { ResponseUser } from '../responses/ResponseUser';
+import { Permission } from './Permission';
 import { Principal } from './Principal';
 import { UserAction } from './UserAction';
 import { UserGroup } from './UserGroup';
@@ -25,9 +26,10 @@ export class User extends Principal {
   * The user's e-mail address.
   * Either username or email has to be set (otherwise the user couldn't log in).
   */
-  @Column({ nullable: true, unique: true })
+  @Column({ nullable: false, unique: true })
   @IsEmail()
-  email?: string;
+  @IsNotEmpty()
+  email: string;
 
   /**
   * The user's phone number.
@@ -128,8 +130,26 @@ export class User extends Principal {
   @OneToMany(() => UserAction, action => action.user, { nullable: true })
   actions: UserAction[]
 
+  /**
+   * Resolves all permissions granted to this user through groups.
+   */
+  public get inheritedPermissions(): Permission[] {
+    let returnPermissions: Permission[] = new Array<Permission>();
+
+    if (!this.groups) { return returnPermissions; }
+    for (let group of this.groups) {
+      if (group.permissions) {
+        for (let permission of group.permissions) {
+          returnPermissions.push(permission);
+        }
+      }
+    }
+    return returnPermissions;
+  }
+
   /**
    * Resolves all permissions granted to this user through groups or directly to the string enum format.
+   * Also deduplicates the array.
    */
   public get allPermissions(): string[] {
     let returnPermissions: string[] = new Array<string>();
@@ -141,8 +161,10 @@ export class User extends Principal {
 
     if (!this.groups) { return returnPermissions; }
     for (let group of this.groups) {
-      for (let permission of group.permissions) {
-        returnPermissions.push(permission.toString());
+      if (group.permissions) {
+        for (let permission of group.permissions) {
+          returnPermissions.push(permission.toString());
+        }
       }
     }
     return Array.from(new Set(returnPermissions));

src/models/entities/UserGroup.ts

@@ -1,40 +1,40 @@
-import {
-  IsNotEmpty,
-  IsOptional,
-  IsString
-} from "class-validator";
-import { ChildEntity, Column } from "typeorm";
-import { ResponsePrincipal } from '../responses/ResponsePrincipal';
-import { ResponseUserGroup } from '../responses/ResponseUserGroup';
-import { Principal } from './Principal';
-
-/**
- * Defines the UserGroup entity.
- * This entity describes a group of users with a set of permissions.
-*/
-@ChildEntity()
-export class UserGroup extends Principal {
-
-  /**
-   * The group's name
-   */
-  @Column()
-  @IsNotEmpty()
-  @IsString()
-  name: string;
-
-  /**
-   * The group's description
-   */
-  @Column({ nullable: true })
-  @IsOptional()
-  @IsString()
-  description?: string;
-
-  /**
-   * Turns this entity into it's response class.
-   */
-  public toResponse(): ResponsePrincipal {
-    return new ResponseUserGroup(this);
-  }
+import {
+  IsNotEmpty,
+  IsOptional,
+  IsString
+} from "class-validator";
+import { ChildEntity, Column } from "typeorm";
+import { ResponsePrincipal } from '../responses/ResponsePrincipal';
+import { ResponseUserGroup } from '../responses/ResponseUserGroup';
+import { Principal } from './Principal';
+
+/**
+ * Defines the UserGroup entity.
+ * This entity describes a group of users with a set of permissions.
+*/
+@ChildEntity()
+export class UserGroup extends Principal {
+
+  /**
+   * The group's name
+   */
+  @Column()
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  /**
+   * The group's description
+   */
+  @Column({ nullable: true })
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponsePrincipal {
+    return new ResponseUserGroup(this);
+  }
 }

src/models/enums/PermissionTargets.ts

@@ -13,5 +13,7 @@ export enum PermissionTarget {
     DONOR = 'DONOR',
     SCAN = 'SCAN',
     STATION = 'STATION',
-    CARD = 'CARD'
+    CARD = 'CARD',
+    DONATION = 'DONATION',
+    CONTACT = 'CONTACT'
 }

src/models/responses/ResponseDistanceDonation.ts

@@ -0,0 +1,35 @@
+import { IsInt, IsObject, IsPositive } from 'class-validator';
+import { DistanceDonation } from '../entities/DistanceDonation';
+import { ResponseDonation } from './ResponseDonation';
+import { ResponseRunner } from './ResponseRunner';
+
+/**
+ * Defines the distance donation response.
+*/
+export class ResponseDistanceDonation extends ResponseDonation {
+
+    /**
+     * The donation's associated runner.
+     * Used as the source of the donation's distance.
+     */
+    @IsObject()
+    runner: ResponseRunner;
+
+    /**
+     * The donation's amount donated per distance.
+     * The amount the donor set to be donated per kilometer that the runner ran.
+     */
+    @IsInt()
+    @IsPositive()
+    amountPerDistance: number;
+
+    /**
+     * Creates a ResponseDistanceDonation object from a scan.
+     * @param donation The distance donation the response shall be build for.
+     */
+    public constructor(donation: DistanceDonation) {
+        super(donation);
+        this.runner = donation.runner.toResponse();
+        this.amountPerDistance = donation.amountPerDistance;
+    }
+}

src/models/responses/ResponseDonation.ts

@@ -0,0 +1,37 @@
+import { IsInt, IsNotEmpty, IsPositive } from "class-validator";
+import { Donation } from '../entities/Donation';
+import { ResponseDonor } from './ResponseDonor';
+
+/**
+ * Defines the donation response.
+*/
+export class ResponseDonation {
+    /**
+     * The donation's id.
+     */
+    @IsInt()
+    @IsPositive()
+    id: number;
+
+    /**
+     * The donation's donor.
+     */
+    @IsNotEmpty()
+    donor: ResponseDonor;
+
+    /**
+     * The donation's amount in the smalles unit of your currency (default: euro cent).
+     */
+    @IsInt()
+    amount: number;
+
+    /**
+     * Creates a ResponseDonation object from a scan.
+     * @param donation The donation the response shall be build for.
+     */
+    public constructor(donation: Donation) {
+        this.id = donation.id;
+        this.donor = donation.donor.toResponse();
+        this.amount = donation.amount;
+    }
+}

src/models/responses/ResponseDonor.ts

@@ -1,5 +1,5 @@
 import {
-    IsBoolean
+    IsBoolean, IsInt
 } from "class-validator";
 import { Donor } from '../entities/Donor';
 import { ResponseParticipant } from './ResponseParticipant';
@@ -15,6 +15,12 @@ export class ResponseDonor extends ResponseParticipant {
     @IsBoolean()
     receiptNeeded: boolean;
 
+    /**
+    * Returns the total donations of a donor based on his linked donations.
+    */
+    @IsInt()
+    donationAmount: number;
+
     /**
      * Creates a ResponseRunner object from a runner.
      * @param runner The user the response shall be build for.
@@ -22,5 +28,6 @@ export class ResponseDonor extends ResponseParticipant {
     public constructor(donor: Donor) {
         super(donor);
         this.receiptNeeded = donor.receiptNeeded;
+        this.donationAmount = donor.donationAmount;
     }
 }

src/models/responses/ResponseGroupContact.ts

@@ -0,0 +1,76 @@
+import { IsInt, IsObject, IsString } from "class-validator";
+import { Address } from '../entities/Address';
+import { GroupContact } from '../entities/GroupContact';
+import { ResponseRunnerGroup } from './ResponseRunnerGroup';
+
+/**
+ * Defines the group contact response.
+*/
+export class ResponseGroupContact {
+    /**
+     * The contact's id.
+     */
+    @IsInt()
+    id: number;
+
+    /**
+     * The contact's first name.
+     */
+    @IsString()
+    firstname: string;
+
+    /**
+     * The contact's middle name.
+     */
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The contact's last name.
+     */
+    @IsString()
+    lastname: string;
+
+    /**
+     * The contact's phone number.
+     */
+    @IsString()
+    phone?: string;
+
+    /**
+     * The contact's e-mail address.
+     */
+    @IsString()
+    email?: string;
+
+    /**
+     * The contact's associated runner groups.
+     */
+    @IsObject()
+    groups: ResponseRunnerGroup[];
+
+    /**
+     * The contact's address.
+     * This is a address object to prevent any formatting differences.
+     */
+    @IsObject()
+    address?: Address;
+
+    /**
+     * Creates a ResponseGroupContact object from a contact.
+     * @param contact The contact the response shall be build for.
+     */
+    public constructor(contact: GroupContact) {
+        this.id = contact.id;
+        this.firstname = contact.firstname;
+        this.middlename = contact.middlename;
+        this.lastname = contact.lastname;
+        this.phone = contact.phone;
+        this.email = contact.email;
+        this.address = contact.address;
+        this.groups = new Array<ResponseRunnerGroup>();
+        for (let group of contact.groups) {
+            this.groups.push(group.toResponse());
+        }
+    }
+}

src/models/responses/ResponseParticipant.ts

@@ -1,4 +1,5 @@
-import { IsInt, IsString } from "class-validator";
+import { IsInt, IsObject, IsOptional, IsString } from "class-validator";
+import { Address } from '../entities/Address';
 import { Participant } from '../entities/Participant';
 
 /**
@@ -41,6 +42,13 @@ export abstract class ResponseParticipant {
     @IsString()
     email?: string;
 
+    /**
+     * The participant's address.
+     */
+    @IsOptional()
+    @IsObject()
+    address?: Address;
+
     /**
      * Creates a ResponseParticipant object from a participant.
      * @param participant The participant the response shall be build for.
@@ -52,5 +60,6 @@ export abstract class ResponseParticipant {
         this.lastname = participant.lastname;
         this.phone = participant.phone;
         this.email = participant.email;
+        this.address = participant.address;
     }
 }

src/models/responses/ResponseUser.ts

@@ -1,96 +1,99 @@
-import {
-    IsArray,
-    IsBoolean,
-
-    IsOptional,
-    IsString
-} from "class-validator";
-import { User } from '../entities/User';
-import { UserGroup } from '../entities/UserGroup';
-import { ResponsePrincipal } from './ResponsePrincipal';
-
-/**
- * Defines the user response.
-*/
-export class ResponseUser extends ResponsePrincipal {
-    /**
-     * The user's first name.
-     */
-    @IsString()
-    firstname: string;
-
-    /**
-     * The user's middle name.
-     */
-    @IsString()
-    middlename?: string;
-
-    /**
-     * The user's last name.
-     */
-    @IsString()
-    lastname: string;
-
-    /**
-     * The user's phone number.
-     */
-    @IsString()
-    phone?: string;
-
-    /**
-     * The user's e-mail address.
-     */
-    @IsString()
-    email?: string;
-
-    /**
-     * The user's username.
-     */
-    @IsString()
-    username?: string;
-
-    /**
-    * Is user enabled?
-    */
-    @IsBoolean()
-    enabled: boolean = true;
-
-    /**
-    * The user's profile pic (or rather a url pointing to it).
-    */
-    @IsString()
-    profilePic: string;
-
-    /**
-     * The groups that the user is a part of.
-     */
-    @IsArray()
-    @IsOptional()
-    groups: UserGroup[];
-
-    /**
-     * The user's permissions.
-     */
-    @IsArray()
-    @IsOptional()
-    permissions: string[];
-
-    /**
-     * Creates a ResponseUser object from a user.
-     * @param user The user the response shall be build for.
-     */
-    public constructor(user: User) {
-        super(user);
-        this.firstname = user.firstname;
-        this.middlename = user.middlename;
-        this.lastname = user.lastname;
-        this.phone = user.phone;
-        this.email = user.email;
-        this.username = user.username;
-        this.enabled = user.enabled;
-        this.profilePic = user.profilePic;
-        this.groups = user.groups;
-        this.permissions = user.allPermissions;
-        this.groups.forEach(function (g) { delete g.permissions });
-    }
-}
+import {
+    IsArray,
+    IsBoolean,
+
+    IsOptional,
+    IsString
+} from "class-validator";
+import { User } from '../entities/User';
+import { UserGroup } from '../entities/UserGroup';
+import { ResponsePrincipal } from './ResponsePrincipal';
+
+/**
+ * Defines the user response.
+*/
+export class ResponseUser extends ResponsePrincipal {
+    /**
+     * The user's first name.
+     */
+    @IsString()
+    firstname: string;
+
+    /**
+     * The user's middle name.
+     */
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The user's last name.
+     */
+    @IsString()
+    lastname: string;
+
+    /**
+     * The user's phone number.
+     */
+    @IsString()
+    phone?: string;
+
+    /**
+     * The user's e-mail address.
+     */
+    @IsString()
+    email?: string;
+
+    /**
+     * The user's username.
+     */
+    @IsString()
+    username?: string;
+
+    /**
+    * Is user enabled?
+    */
+    @IsBoolean()
+    enabled: boolean = true;
+
+    /**
+    * The user's profile pic (or rather a url pointing to it).
+    */
+    @IsString()
+    profilePic: string;
+
+    /**
+     * The groups that the user is a part of.
+     */
+    @IsArray()
+    @IsOptional()
+    groups: UserGroup[];
+
+    /**
+     * The user's permissions.
+     * Directly granted or inherited converted to their string form and deduplicated.
+     */
+    @IsArray()
+    @IsOptional()
+    permissions: string[];
+
+    /**
+     * Creates a ResponseUser object from a user.
+     * @param user The user the response shall be build for.
+     */
+    public constructor(user: User) {
+        super(user);
+        this.firstname = user.firstname;
+        this.middlename = user.middlename;
+        this.lastname = user.lastname;
+        this.phone = user.phone;
+        this.email = user.email;
+        this.username = user.username;
+        this.enabled = user.enabled;
+        this.profilePic = user.profilePic;
+        this.groups = user.groups;
+        this.permissions = user.allPermissions;
+        if (this.groups) {
+            this.groups.forEach(function (g) { delete g.permissions });
+        }
+    }
+}

src/models/responses/ResponseUserGroup.ts

@@ -1,41 +1,41 @@
-import { IsArray, IsNotEmpty, IsOptional, IsString } from "class-validator";
-import { Permission } from '../entities/Permission';
-import { UserGroup } from '../entities/UserGroup';
-import { ResponsePrincipal } from './ResponsePrincipal';
-
-/**
- * Defines the userGroup response.
-*/
-export class ResponseUserGroup extends ResponsePrincipal {
-    /**
-     * The userGroup's name.
-     */
-    @IsNotEmpty()
-    @IsString()
-    name: string;
-
-    /**
-     * The userGroup's description.
-     */
-    @IsOptional()
-    @IsString()
-    description?: string;
-
-    /**
-     * The userGroup's permissions.
-     */
-    @IsArray()
-    @IsOptional()
-    permissions: Permission[];
-
-    /**
-     * Creates a ResponseUserGroup object from a userGroup.
-     * @param group The userGroup the response shall be build for.
-     */
-    public constructor(group: UserGroup) {
-        super(group);
-        this.name = group.name;
-        this.description = group.description;
-        this.permissions = group.permissions;
-    }
-}
+import { IsArray, IsNotEmpty, IsOptional, IsString } from "class-validator";
+import { Permission } from '../entities/Permission';
+import { UserGroup } from '../entities/UserGroup';
+import { ResponsePrincipal } from './ResponsePrincipal';
+
+/**
+ * Defines the userGroup response.
+*/
+export class ResponseUserGroup extends ResponsePrincipal {
+    /**
+     * The userGroup's name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    name: string;
+
+    /**
+     * The userGroup's description.
+     */
+    @IsOptional()
+    @IsString()
+    description?: string;
+
+    /**
+     * The userGroup's permissions.
+     */
+    @IsArray()
+    @IsOptional()
+    permissions: Permission[];
+
+    /**
+     * Creates a ResponseUserGroup object from a userGroup.
+     * @param group The userGroup the response shall be build for.
+     */
+    public constructor(group: UserGroup) {
+        super(group);
+        this.name = group.name;
+        this.description = group.description;
+        this.permissions = group.permissions;
+    }
+}

src/models/responses/ResponseUserPermissions.ts

@@ -0,0 +1,40 @@
+import {
+    IsArray,
+
+
+    IsOptional
+} from "class-validator";
+import { User } from '../entities/User';
+import { ResponsePermission } from './ResponsePermission';
+
+/**
+ * Defines the user permission response (get /api/users/:id/permissions).
+*/
+export class ResponseUserPermissions {
+    /**
+     * The permissions directly granted to the user.
+     */
+    @IsArray()
+    @IsOptional()
+    directlyGranted: ResponsePermission[] = new Array<ResponsePermission>();
+
+    /**
+     * The permissions directly inherited the user.
+     */
+    @IsArray()
+    @IsOptional()
+    inherited: ResponsePermission[] = new Array<ResponsePermission>();
+
+    /**
+     * Creates a ResponseUserPermissions object from a user.
+     * @param user The user the response shall be build for.
+     */
+    public constructor(user: User) {
+        for (let permission of user.permissions) {
+            this.directlyGranted.push(permission.toResponse());
+        }
+        for (let permission of user.inheritedPermissions) {
+            this.inherited.push(permission.toResponse());
+        }
+    }
+}

src/seeds/SeedUsers.ts

@@ -33,6 +33,7 @@ export default class SeedUsers implements Seeder {
         initialUser.lastname = "demo";
         initialUser.username = "demo";
         initialUser.password = "demo";
+        initialUser.email = "demo@dev.lauf-fuer-kaya.de"
         initialUser.groups = group;
         return await connection.getRepository(User).save(await initialUser.toEntity());
     }

src/tests/auth/auth_logout.spec.ts

@@ -14,7 +14,8 @@ beforeAll(async () => {
         "middlename": "demo_logout",
         "lastname": "demo_logout",
         "username": "demo_logout",
-        "password": "demo_logout"
+        "password": "demo_logout",
+        "email": "demo_logout@dev.lauf-fuer-kaya.de"
     }, {
         headers: { "authorization": "Bearer " + res_login.data["access_token"] },
         validateStatus: undefined

src/tests/auth/auth_refresh.spec.ts

@@ -14,7 +14,8 @@ beforeAll(async () => {
         "middlename": "demo_refresh",
         "lastname": "demo_refresh",
         "username": "demo_refresh",
-        "password": "demo_refresh"
+        "password": "demo_refresh",
+        "email": "demo_refresh@dev.lauf-fuer-kaya.de"
     }, {
         headers: { "authorization": "Bearer " + res_login.data["access_token"] },
         validateStatus: undefined

src/tests/auth/auth_reset.spec.ts

@@ -14,7 +14,8 @@ beforeAll(async () => {
         "middlename": "demo_reset",
         "lastname": "demo_reset",
         "username": "demo_reset",
-        "password": "demo_reset"
+        "password": "demo_reset",
+        "email": "demo_reset@dev.lauf-fuer-kaya.de"
     }, {
         headers: { "authorization": "Bearer " + res_login.data["access_token"] },
         validateStatus: undefined
@@ -24,7 +25,8 @@ beforeAll(async () => {
         "middlename": "demo_reset2",
         "lastname": "demo_reset2",
         "username": "demo_reset2",
-        "password": "demo_reset2"
+        "password": "demo_reset2",
+        "email": "demo_reset1@dev.lauf-fuer-kaya.de"
     }, {
         headers: { "authorization": "Bearer " + res_login.data["access_token"] },
         validateStatus: undefined

src/tests/contacts/contact_add.spec.ts

@@ -0,0 +1,216 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+// ---------------
+describe('POST /api/contacts with errors', () => {
+    it('creating a new contact without any parameters should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', null, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact without a last name should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle"
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid phone number should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle",
+            "lastname": "last",
+            "phone": "123"
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid mail address should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "phone": null,
+            "email": "123",
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with an invalid address 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "address": {
+                "city": "Testcity"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid group should return 404', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "groups": 9999999999999
+        }, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('POST /api/contacts working (simple)', () => {
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with all non-relationship optional params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle",
+            "lastname": "last",
+            "email": "testContact@lauf-fuer-kaya.de",
+            "phone": "+49017612345678",
+            "address": {
+                "address1": "test",
+                "address2": null,
+                "city": "herzogenaurach",
+                "country": "germany",
+                "postalcode": "91074",
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('POST /api/contacts working (with group)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('creating a new contact with a valid team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_team]
+        });
+    });
+    it('creating a new contact with a valid org and team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org, added_team]
+        });
+    });
+    it('checking if the added team\'s contact is the new contact should return 200', async () => {
+        const res = await axios.get(base + '/api/teams/' + added_team.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.contact.groups;
+        delete res.data.contact.id;
+        delete added_contact.groups;
+        expect(res.data.contact).toEqual(added_contact);
+    });
+});

src/tests/contacts/contact_delete.spec.ts

@@ -0,0 +1,183 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('adding + deletion (non-existant)', () => {
+    it('delete', async () => {
+        const res = await axios.delete(base + '/api/contacts/0', axios_config);
+        expect(res.status).toEqual(204);
+    });
+});
+// ---------------
+describe('add+delete (simple)', () => {
+    let added_contact;
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let deleted_contact = res.data
+        expect(deleted_contact).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with org)', () => {
+    let added_org;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with team)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with org&team)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org and team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        delete res.data.groups[1].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});

src/tests/contacts/contact_get.spec.ts

@@ -0,0 +1,57 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('GET /api/contacts', () => {
+    it('basic get should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts', axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('GET /api/contacts/0', () => {
+    it('basic get should return 404', async () => {
+        const res = await axios.get(base + '/api/contacts/0', axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('GET /api/contacts after adding', () => {
+    let added_contact;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('explicit get should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_donor = res.data
+        expect(gotten_donor).toEqual(added_contact);
+    });
+    it('get from all runners should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts/', axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_donors = res.data
+        expect(gotten_donors).toContainEqual(added_contact);
+    });
+});

src/tests/contacts/contact_update.spec.ts

@@ -0,0 +1,237 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('Update contact name after adding', () => {
+    let added_contact;
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('valid update should return 200', async () => {
+        let contact_copy = added_contact
+        contact_copy.firstname = "second"
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, contact_copy, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        expect(res.data).toEqual(contact_copy);
+    });
+});
+// ---------------
+describe('Update contact id after adding(should fail)', () => {
+    let added_contact;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('invalid update should return 406', async () => {
+        added_contact.id++;
+        const res = await axios.put(base + '/api/contacts/' + (added_contact.id - 1), added_contact, axios_config);
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('Update contact group after adding (should work)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('valid group update to single team should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_team]
+        });
+    });
+    it('valid group update to org and team should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org, added_team]
+        });
+    });
+    it('valid group update to none should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": null
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": []
+        });
+    });
+});
+// ---------------
+describe('Update contact group invalid after adding (should fail)', () => {
+    let added_org;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('invalid group update to single team should return 404', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": 999999999999999
+        }, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+});

src/tests/donations/donations_add.spec.ts

@@ -0,0 +1,236 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+	const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+	access_token = res.data["access_token"];
+	axios_config = {
+		headers: { "authorization": "Bearer " + access_token },
+		validateStatus: undefined
+	};
+});
+
+describe('POST /api/donations illegally', () => {
+	it('posting to a non-existant endpoint should return 4040', async () => {
+		const res1 = await axios.post(base + '/api/donations', null, axios_config);
+		expect(res1.status).toEqual(404);
+	});
+});
+// ---------------
+describe('POST /api/donations/fixed illegally', () => {
+	let added_donor;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no input should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', null, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no donor should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"amount": 100
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no amount should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('illegal amount input should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": -1
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('invalid donor input should return 404', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": 999999999999999999999999,
+			"amount": 100
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('POST /api/donations/distance illegally', () => {
+	let added_donor;
+	let added_org;
+	let added_runner;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no input should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/distance', null, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no donor should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no amountPerDistance should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('no runner should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('illegal amountPerDistance input should return 400', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": -1,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('invalid donor input should return 404', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"donor": 999999999999999999999999,
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('invalid runner input should return 404', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"donor": added_donor.id,
+			"runner": 999999999999999999999999,
+			"amountPerDistance": 100,
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('POST /api/donations/fixed successfully', () => {
+	let added_donor;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		delete res.data.id;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data).toEqual({
+			"donor": added_donor,
+			"amount": 1000
+		});
+	});
+});
+// ---------------
+describe('POST /api/donations/distance successfully', () => {
+	let added_donor;
+	let added_org;
+	let added_runner;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		delete res.data.group;
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.id;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data).toEqual({
+			"donor": added_donor,
+			"amountPerDistance": 100,
+			"runner": added_runner,
+			"amount": 0
+		})
+	});
+});

src/tests/donations/donations_delete.spec.ts

@@ -0,0 +1,113 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+	const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+	access_token = res.data["access_token"];
+	axios_config = {
+		headers: { "authorization": "Bearer " + access_token },
+		validateStatus: undefined
+	};
+});
+
+describe('DELETE donation (non-existant)', () => {
+	it('delete', async () => {
+		const res = await axios.delete(base + '/api/donations/0', axios_config);
+		expect(res.status).toEqual(204);
+	});
+});
+// ---------------
+describe('DELETE fixed donation', () => {
+	let added_donor;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('delete donation', async () => {
+		const res = await axios.delete(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+		expect(res.data).toEqual(added_donation);
+	});
+	it('check if donation really was deleted', async () => {
+		const res = await axios.get(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('DELETE distance donation', () => {
+	let added_donor;
+	let added_org;
+	let added_runner;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new distance donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.runner.distance;
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('delete donation', async () => {
+		const res = await axios.delete(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+		delete res.data.runner.distance;
+		expect(res.data).toEqual(added_donation);
+	});
+	it('check if donation really was deleted', async () => {
+		const res = await axios.get(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});

src/tests/donations/donations_get.spec.ts

@@ -0,0 +1,108 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+	const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+	access_token = res.data["access_token"];
+	axios_config = {
+		headers: { "authorization": "Bearer " + access_token },
+		validateStatus: undefined
+	};
+});
+
+describe('GET /api/donations sucessfully', () => {
+	it('basic get should return 200', async () => {
+		const res = await axios.get(base + '/api/donations', axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('GET /api/donations illegally', () => {
+	it('get for non-existant track should return 404', async () => {
+		const res = await axios.get(base + '/api/donations/-1', axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('adding + getting fixed donation', () => {
+	let added_donor;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('check if donation was added (no parameter validation)', async () => {
+		const res = await axios.get(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+	});
+});
+// ---------------
+describe('adding + getting distance donation', () => {
+	let added_donor;
+	let added_org;
+	let added_runner;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('check if donation was added (no parameter validation)', async () => {
+		const res = await axios.get(base + '/api/donations/' + added_donation.id, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+	});
+});

src/tests/donations/donations_update.spec.ts

@@ -0,0 +1,343 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+	const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+	access_token = res.data["access_token"];
+	axios_config = {
+		headers: { "authorization": "Bearer " + access_token },
+		validateStatus: undefined
+	};
+});
+
+describe('adding + updating fixed donation illegally', () => {
+	let added_donor;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating empty should return 400', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, null, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with wrong id should return 406', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id + 1,
+			"donor": added_donor.id,
+			"amount": 100
+		}, axios_config);
+		expect(res.status).toEqual(406);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with negative amount should return 400', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id,
+			"donor": added_donor.id,
+			"amount": -1
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with invalid donor should return 404', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id,
+			"donor": 9999999999999999999,
+			"amount": 100
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('adding + updating distance donation illegally', () => {
+	let added_donor;
+	let added_org;
+	let added_runner;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new distance donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating empty should return 400', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, null, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with wrong id should return 406', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id + 1,
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(406);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with negative amountPerDistance should return 400', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner.id,
+			"amountPerDistance": -1,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(400);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with invalid donor should return 404', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": 9999999999999999999
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating with invalid runner should return 404', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": 9999999999999999999,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('adding + updating fixed donation valid', () => {
+	let added_donor;
+	let added_donor2;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		delete res.data.donationAmount;
+		added_donor2 = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new fixed donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/fixed', {
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating nothing should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id,
+			"donor": added_donor.id,
+			"amount": 1000
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data).toEqual(added_donation);
+	});
+	it('updating amount should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id,
+			"donor": added_donor.id,
+			"amount": 42
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data.amount).toEqual(42);
+	});
+	it('updating donor should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/fixed/' + added_donation.id, {
+			"id": added_donation.id,
+			"donor": added_donor2.id,
+			"amount": 42
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data.donor).toEqual(added_donor2);
+	});
+});
+// ---------------
+describe('adding + updating distance donation valid', () => {
+	let added_donor;
+	let added_donor2;
+	let added_org;
+	let added_runner;
+	let added_runner2;
+	let added_donation;
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		delete res.data.donationAmount;
+		added_donor = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new donor with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/donors', {
+			"firstname": "first",
+			"lastname": "last"
+		}, axios_config);
+		delete res.data.donationAmount;
+		added_donor2 = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new org with just a name should return 200', async () => {
+		const res = await axios.post(base + '/api/organisations', {
+			"name": "test123"
+		}, axios_config);
+		added_org = res.data
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		added_runner = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		delete res.data.group;
+		added_runner2 = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new distance donation should return 200', async () => {
+		const res = await axios.post(base + '/api/donations/distance', {
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		added_donation = res.data;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+	it('updating nothing should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner.id,
+			"amountPerDistance": 100,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data).toEqual(added_donation);
+	});
+	it('updating amount should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner.id,
+			"amountPerDistance": 69,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data.amountPerDistance).toEqual(69);
+	});
+	it('updating runner should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner2.id,
+			"amountPerDistance": 69,
+			"donor": added_donor.id
+		}, axios_config);
+		delete res.data.runner.group;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data.runner).toEqual(added_runner2);
+	});
+	it('updating donor should return 200', async () => {
+		const res = await axios.put(base + '/api/donations/distance/' + added_donation.id, {
+			"id": added_donation.id,
+			"runner": added_runner2.id,
+			"amountPerDistance": 69,
+			"donor": added_donor2.id
+		}, axios_config);
+		delete res.data.donor.donationAmount;
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data.donor).toEqual(added_donor2);
+	});
+});

src/tests/donors/donor_add.spec.ts

@@ -29,16 +29,6 @@ describe('POST /api/donors with errors', () => {
         expect(res2.status).toEqual(400);
         expect(res2.headers['content-type']).toContain("application/json")
     });
-    it('creating a new donor with a invalid address should return 404', async () => {
-        const res2 = await axios.post(base + '/api/donors', {
-            "firstname": "first",
-            "middlename": "middle",
-            "lastname": "last",
-            "address": 0
-        }, axios_config);
-        expect(res2.status).toEqual(404);
-        expect(res2.headers['content-type']).toContain("application/json")
-    });
     it('creating a new donor with a invalid phone number should return 400', async () => {
         const res2 = await axios.post(base + '/api/donors', {
             "firstname": "first",

src/tests/donors/donor_delete.spec.ts

@@ -44,4 +44,114 @@ describe('add+delete', () => {
         expect(res4.status).toEqual(404);
         expect(res4.headers['content-type']).toContain("application/json")
     });
+});
+// ---------------
+describe('DELETE donor with donations invalid', () => {
+    let added_donor;
+    let added_org;
+    let added_runner;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/donors', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_donor = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_org.id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new fixed donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/fixed', {
+            "donor": added_donor.id,
+            "amount": 1000
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new distance donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/distance', {
+            "runner": added_runner.id,
+            "amountPerDistance": 100,
+            "donor": added_donor.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete donor w/o force', async () => {
+        const res = await axios.delete(base + '/api/donors/' + added_donor.id, axios_config);
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('DELETE donor with donations valid', () => {
+    let added_donor;
+    let added_org;
+    let added_runner;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/donors', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_donor = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_org.id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new fixed donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/fixed', {
+            "donor": added_donor.id,
+            "amount": 1000
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new distance donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/distance', {
+            "runner": added_runner.id,
+            "amountPerDistance": 100,
+            "donor": added_donor.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete donor w/ force ', async () => {
+        const res = await axios.delete(base + '/api/donors/' + added_donor.id + "?force=true", axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
 });

src/tests/donors/donor_update.spec.ts

@@ -60,7 +60,7 @@ describe('Update donor without address but receiptNeeded=true should fail', () =
     it('creating a new donor with only needed params should return 200', async () => {
         const res2 = await axios.post(base + '/api/donors', {
             "firstname": "first",
-            "lastname": "last",
+            "lastname": "testtest",
         }, axios_config);
         added_donor = res2.data;
         expect(res2.status).toEqual(200);

src/tests/runnerOrgs/org_add.spec.ts

@@ -56,7 +56,13 @@ describe('adding + getting from all orgs', () => {
         expect(added_org).toEqual({
             "name": "test123",
             "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
             "teams": []
         })
     });
@@ -83,7 +89,13 @@ describe('adding + getting explicitly', () => {
         expect(added_org2).toEqual({
             "name": "test123",
             "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
             "teams": []
         })
     });

src/tests/runnerOrgs/org_delete.spec.ts

@@ -44,7 +44,13 @@ describe('adding + deletion (successfull)', () => {
         expect(added_org2).toEqual({
             "name": "test123",
             "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
             "teams": []
         });
     });
@@ -121,7 +127,13 @@ describe('adding + deletion with teams still existing (with force)', () => {
         expect(added_org2).toEqual({
             "name": "test123",
             "contact": null,
-            "address": null
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
         });
     });
     it('check if org really was deleted', async () => {

src/tests/runnerOrgs/org_update.spec.ts

@@ -19,30 +19,36 @@ describe('adding + updating name', () => {
     let added_org_id
     let added_org
     it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organisations', {
             "name": "test123"
         }, axios_config);
-        added_org = res1.data
+        added_org = res.data
         added_org_id = added_org.id;
-        expect(res1.status).toEqual(200);
-        expect(res1.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
     });
     it('update org', async () => {
-        const res2 = await axios.put(base + '/api/organisations/' + added_org_id, {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
             "id": added_org_id,
             "name": "testlelele",
             "contact": null,
             "address": null,
         }, axios_config);
-        expect(res2.status).toEqual(200);
-        expect(res2.headers['content-type']).toContain("application/json")
-        let added_org2 = res2.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let added_org2 = res.data
         added_org_id = added_org2.id;
         delete added_org2.id
         expect(added_org2).toEqual({
             "name": "testlelele",
             "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
             "teams": []
         })
     });
@@ -52,22 +58,326 @@ describe('adding + try updating id (should return 406)', () => {
     let added_org_id
     let added_org
     it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organisations', {
             "name": "test123"
         }, axios_config);
-        added_org = res1.data
+        added_org = res.data
         added_org_id = added_org.id;
-        expect(res1.status).toEqual(200);
-        expect(res1.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
     });
     it('update org', async () => {
-        const res2 = await axios.put(base + '/api/organisations/' + added_org_id, {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
             "id": added_org_id + 1,
             "name": "testlelele",
             "contact": null,
             "address": null,
         }, axios_config);
-        expect(res2.status).toEqual(406);
-        expect(res2.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('adding + updateing address valid)', () => {
+    let added_org_id
+    let added_org
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('adding address to org should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "Herzogenaurach",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "Herzogenaurach",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "teams": []
+        });
+    });
+    it('updateing address\'s first line should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "teams": []
+        });
+    });
+    it('updateing address\'s second line should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "teams": []
+        });
+    });
+    it('updateing address\'s city should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "teams": []
+        });
+    });
+    it('updateing address\'s country should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "90174"
+            },
+            "teams": []
+        });
+    });
+    it('updateing address\'s postal code should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "91065"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "91065"
+            },
+            "teams": []
+        });
+    });
+    it('removing org\'s should return 200', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null
+            },
+            "teams": []
+        });
+    });
+});
+// ---------------
+describe('adding + updateing address invalid)', () => {
+    let added_org_id
+    let added_org
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('adding address to org w/o address1 should return 400', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o city should return 400', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": null,
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o country should return 400', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": null,
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o postal code should return 400', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": null
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/ invalid postal code should return 400', async () => {
+        const res = await axios.put(base + '/api/organisations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "-1"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
     });
 });

src/tests/runnerTeams/team_update.spec.ts

@@ -43,7 +43,7 @@ describe('adding + updating name', () => {
             "id": added_team_id,
             "name": "testlelele",
             "contact": null,
-            "parentGroup": added_org
+            "parentGroup": added_org.id
         }, axios_config);
         expect(res3.status).toEqual(200);
         expect(res3.headers['content-type']).toContain("application/json")
@@ -79,6 +79,7 @@ describe('adding + try updating id (should return 406)', () => {
     });
     it('update team', async () => {
         added_team.id = added_team.id + 1;
+        added_team.parentGroup = added_team.parentGroup.id;
         const res3 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config);
         expect(res3.status).toEqual(406);
         expect(res3.headers['content-type']).toContain("application/json")
@@ -117,14 +118,13 @@ describe('add+update parent org (valid)', () => {
         expect(res3.headers['content-type']).toContain("application/json")
     });
     it('update team', async () => {
-        added_team.parentGroup = added_org2;
+        added_team.parentGroup = added_org2.id;
         const res4 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config);
         let updated_team = res4.data;
         expect(res4.status).toEqual(200);
         expect(res4.headers['content-type']).toContain("application/json")
-        delete added_org2.address;
         delete added_org2.contact;
         delete added_org2.teams;
-        expect(updated_team).toEqual(added_team)
+        expect(updated_team.parentGroup).toEqual(added_org2)
     });
 });

src/tests/runners/runner_delete.spec.ts

@@ -55,4 +55,98 @@ describe('add+delete', () => {
         expect(res4.status).toEqual(404);
         expect(res4.headers['content-type']).toContain("application/json")
     });
+});
+// ---------------
+describe('DELETE donor with donations invalid', () => {
+    let added_donor;
+    let added_org;
+    let added_runner;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/donors', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_donor = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_org.id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new distance donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/distance', {
+            "runner": added_runner.id,
+            "amountPerDistance": 100,
+            "donor": added_donor.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete runner w/o force', async () => {
+        const res = await axios.delete(base + '/api/runners/' + added_runner.id, axios_config);
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('DELETE donor with donations valid', () => {
+    let added_donor;
+    let added_org;
+    let added_runner;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/donors', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_donor = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organisations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_org.id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new distance donation should return 200', async () => {
+        const res = await axios.post(base + '/api/donations/distance', {
+            "runner": added_runner.id,
+            "amountPerDistance": 100,
+            "donor": added_donor.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete donor w/ force ', async () => {
+        const res = await axios.delete(base + '/api/runners/' + added_runner.id + "?force=true", axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
 });

src/tests/runners/runner_update.spec.ts

@@ -15,15 +15,14 @@ beforeAll(async () => {
 });
 
 describe('Update runner name after adding', () => {
-    let added_org_id;
+    let added_org;
     let added_runner;
     let updated_runner;
     it('creating a new org with just a name should return 200', async () => {
         const res1 = await axios.post(base + '/api/organisations', {
             "name": "test123"
         }, axios_config);
-        let added_org = res1.data
-        added_org_id = added_org.id;
+        added_org = res1.data
         expect(res1.status).toEqual(200);
         expect(res1.headers['content-type']).toContain("application/json")
     });
@@ -31,7 +30,7 @@ describe('Update runner name after adding', () => {
         const res2 = await axios.post(base + '/api/runners', {
             "firstname": "first",
             "lastname": "last",
-            "group": added_org_id
+            "group": added_org.id
         }, axios_config);
         added_runner = res2.data;
         expect(res2.status).toEqual(200);
@@ -40,10 +39,14 @@ describe('Update runner name after adding', () => {
     it('valid update should return 200', async () => {
         let runnercopy = added_runner
         runnercopy.firstname = "second"
+        runnercopy.group = added_runner.group.id;
         const res3 = await axios.put(base + '/api/runners/' + added_runner.id, runnercopy, axios_config);
         expect(res3.status).toEqual(200);
         expect(res3.headers['content-type']).toContain("application/json")
-        updated_runner = res3.data
+        updated_runner = res3.data;
+        delete added_org.contact;
+        delete added_org.teams;
+        runnercopy.group = added_org;
         expect(updated_runner).toEqual(runnercopy);
     });
 });
@@ -52,7 +55,6 @@ describe('Update runner group after adding', () => {
     let added_org_id;
     let added_org_2;
     let added_runner;
-    let updated_runner;
     it('creating a new org with just a name should return 200', async () => {
         const res1 = await axios.post(base + '/api/organisations', {
             "name": "test123"
@@ -77,19 +79,17 @@ describe('Update runner group after adding', () => {
             "name": "test123"
         }, axios_config);
         added_org_2 = res3.data
-        delete added_org_2.address;
         delete added_org_2.contact;
         delete added_org_2.teams;
         expect(res3.status).toEqual(200);
         expect(res3.headers['content-type']).toContain("application/json")
     });
-    it('valid update should return 200', async () => {
-        added_runner.group = added_org_2;
+    it('valid group update should return 200', async () => {
+        added_runner.group = added_org_2.id;
         const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
         expect(res3.status).toEqual(200);
         expect(res3.headers['content-type']).toContain("application/json")
-        updated_runner = res3.data
-        expect(updated_runner).toEqual(added_runner);
+        expect(res3.data.group).toEqual(added_org_2);
     });
 });
 // ---------------
@@ -119,6 +119,7 @@ describe('Update runner id after adding(should fail)', () => {
     });
     it('invalid update should return 406', async () => {
         added_runner.id++;
+        added_runner.group = added_runner.group.id;
         const res3 = await axios.put(base + '/api/runners/' + added_runner_id, added_runner, axios_config);
         expect(res3.status).toEqual(406);
         expect(res3.headers['content-type']).toContain("application/json")
@@ -146,9 +147,8 @@ describe('Update runner group with invalid group after adding', () => {
         expect(res2.status).toEqual(200);
         expect(res2.headers['content-type']).toContain("application/json")
     });
-    it('invalid update should return 404', async () => {
-        added_org.id = 0;
-        added_runner.group = added_org;
+    it('invalid group update should return 404', async () => {
+        added_runner.group = 99999999999999999;
         const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
         expect(res3.status).toEqual(404);
         expect(res3.headers['content-type']).toContain("application/json")