Merge pull request 'Alpha Release 0.0.11' (#87 ) from dev into main

Reviewed-on: #87 Reviewed-by: Philipp Dormann <philipp@philippdormann.de>
Version bump
2021-01-10 17:16:09 +00:00 · 2021-01-10 18:13:08 +01:00 · 2021-01-10 17:11:31 +00:00 · 2021-01-10 18:09:57 +01:00 · 2021-01-10 18:01:22 +01:00 · 2021-01-10 17:47:31 +01:00
115 changed files with 4118 additions and 619 deletions
--- a/.drone.yml
+++ b/.drone.yml
@@ -11,7 +11,7 @@ steps:
      - git checkout $DRONE_SOURCE_BRANCH
      - mv .env.ci .env
  - name: run tests
-    image: node:alpine
+    image: node:14.15.1-alpine3.12
    commands:
      - yarn
      - yarn test:ci
@@ -39,7 +39,7 @@ steps:
      registry: registry.odit.services
  - name: run full license export
    depends_on: ["clone"]
-    image: node:alpine
+    image: node:14.15.1-alpine3.12
    commands:
      - yarn
      - yarn licenses:export
--- a/.gitignore
+++ b/.gitignore
@@ -134,4 +134,5 @@ build
 *.sqlite-jurnal
 /docs
 lib
-/oss-attribution
+/oss-attribution
+*.tmp
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@odit/lfk-backend",
-  "version": "0.0.8",
+  "version": "0.0.11",
  "main": "src/app.ts",
  "repository": "https://git.odit.services/lfk/backend",
  "author": {
@@ -22,11 +22,11 @@
  ],
  "license": "CC-BY-NC-SA-4.0",
  "dependencies": {
-    "argon2": "^0.27.0",
+    "argon2": "^0.27.1",
    "body-parser": "^1.19.0",
    "class-transformer": "^0.3.1",
    "class-validator": "^0.12.2",
-    "class-validator-jsonschema": "^2.0.3",
+    "class-validator-jsonschema": "^2.1.0",
    "consola": "^2.15.0",
    "cookie": "^0.4.1",
    "cookie-parser": "^1.4.5",
@@ -39,33 +39,34 @@
    "pg": "^8.5.1",
    "reflect-metadata": "^0.1.13",
    "routing-controllers": "^0.9.0-alpha.6",
-    "routing-controllers-openapi": "^2.1.0",
-    "sqlite3": "^5.0.0",
+    "routing-controllers-openapi": "^2.2.0",
+    "sqlite3": "5.0.0",
    "typeorm": "^0.2.29",
    "typeorm-routing-controllers-extensions": "^0.2.0",
    "typeorm-seeding": "^1.6.1",
-    "uuid": "^8.3.1",
+    "uuid": "^8.3.2",
    "validator": "^13.5.2"
  },
  "devDependencies": {
-    "@odit/license-exporter": "^0.0.8",
-    "@types/cors": "^2.8.8",
+    "@odit/license-exporter": "^0.0.9",
+    "@types/cors": "^2.8.9",
    "@types/csvtojson": "^1.1.5",
    "@types/express": "^4.17.9",
    "@types/jest": "^26.0.16",
    "@types/jsonwebtoken": "^8.5.0",
-    "@types/node": "^14.14.9",
+    "@types/node": "^14.14.20",
    "@types/uuid": "^8.3.0",
-    "axios": "^0.21.0",
+    "axios": "^0.21.1",
    "cp-cli": "^2.0.0",
    "jest": "^26.6.3",
-    "nodemon": "^2.0.6",
-    "rimraf": "^2.7.1",
-    "start-server-and-test": "^1.11.6",
+    "nodemon": "^2.0.7",
+    "release-it": "^14.2.2",
+    "rimraf": "^3.0.2",
+    "start-server-and-test": "^1.11.7",
    "ts-jest": "^26.4.4",
-    "ts-node": "^9.0.0",
-    "typedoc": "^0.19.2",
-    "typescript": "^4.1.2"
+    "ts-node": "^9.1.1",
+    "typedoc": "^0.20.14",
+    "typescript": "^4.1.3"
  },
  "scripts": {
    "dev": "nodemon src/app.ts",
@@ -76,7 +77,21 @@
    "test:ci": "start-server-and-test dev http://localhost:4010/api/docs/openapi.json test",
    "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"
+    "licenses:export": "license-exporter --md",
+    "release": "release-it"
+  },
+  "release-it": {
+    "git": {
+      "requireCleanWorkingDir": false,
+      "requireBranch": "main",
+      "push": false,
+      "tag": true,
+      "tagName": "v${version}",
+      "tagAnnotation": "v${version}"
+    },
+    "npm": {
+      "publish": false
+    }
  },
  "nodemonConfig": {
    "ignore": [
--- a/scripts/openapi_export.ts
+++ b/scripts/openapi_export.ts
@@ -3,7 +3,7 @@ import consola from "consola";
 import fs from "fs";
 import "reflect-metadata";
 import { createExpressServer, getMetadataArgsStorage } from "routing-controllers";
-import { routingControllersToSpec } from 'routing-controllers-openapi';
+import { generateSpec } from '../src/apispec';
 import { config } from '../src/config';
 import authchecker from "../src/middlewares/authchecker";
 import { ErrorHandler } from '../src/middlewares/ErrorHandler';
@@ -24,41 +24,7 @@ const schemas = validationMetadatasToSchemas({
 });

 //Spec creation based on the previously created schemas
-const spec = routingControllersToSpec(
-    storage,
-    {
-        routePrefix: "/api"
-    },
-    {
-        components: {
-            schemas,
-            "securitySchemes": {
-                "AuthToken": {
-                    "type": "http",
-                    "scheme": "bearer",
-                    "bearerFormat": "JWT",
-                    description: "A JWT based access token. Use /api/auth/login or /api/auth/refresh to get one."
-                },
-                "RefreshTokenCookie": {
-                    "type": "apiKey",
-                    "in": "cookie",
-                    "name": "lfk_backend__refresh_token",
-                    description: "A cookie containing a JWT based refreh token. Attention: Doesn't work in swagger-ui. Use /api/auth/login or /api/auth/refresh to get one."
-                },
-                "StatsApiToken": {
-                    "type": "http",
-                    "scheme": "bearer",
-                    description: "Api token that can be obtained by creating a new stats client (post to /api/statsclients)."
-                }
-            }
-        },
-        info: {
-            description: "The the backend API for the LfK! runner system.",
-            title: "LfK! Backend API",
-            version: "0.0.8",
-        },
-    }
-);
+const spec = generateSpec(storage, schemas);

 try {
    fs.writeFileSync("./openapi.json", JSON.stringify(spec), { encoding: "utf-8" });
--- a/src/apispec.ts
+++ b/src/apispec.ts
@@ -0,0 +1,50 @@
+import { MetadataArgsStorage } from 'routing-controllers';
+import { routingControllersToSpec } from 'routing-controllers-openapi';
+
+/**
+ * This function generates a the openapi spec from route metadata and type schemas.
+ * @param storage MetadataArgsStorage object generated by routing-controllers.
+ * @param schemas MetadataArgsStorage object generated by class-validator-jsonschema.
+ */
+export function generateSpec(storage: MetadataArgsStorage, schemas) {
+    return routingControllersToSpec(
+        storage,
+        {
+            routePrefix: "/api"
+        },
+        {
+            components: {
+                schemas,
+                "securitySchemes": {
+                    "AuthToken": {
+                        "type": "http",
+                        "scheme": "bearer",
+                        "bearerFormat": "JWT",
+                        description: "A JWT based access token. Use /api/auth/login or /api/auth/refresh to get one."
+                    },
+                    "RefreshTokenCookie": {
+                        "type": "apiKey",
+                        "in": "cookie",
+                        "name": "lfk_backend__refresh_token",
+                        description: "A cookie containing a JWT based refreh token. Attention: Doesn't work in swagger-ui. Use /api/auth/login or /api/auth/refresh to get one."
+                    },
+                    "StatsApiToken": {
+                        "type": "http",
+                        "scheme": "bearer",
+                        description: "Api token that can be obtained by creating a new stats client (post to /api/statsclients). Only valid for obtaining stats."
+                    },
+                    "StationApiToken": {
+                        "type": "http",
+                        "scheme": "bearer",
+                        description: "Api token that can be obtained by creating a new scan station (post to /api/stations). Only valid for creating scans."
+                    }
+                }
+            },
+            info: {
+                description: "The the backend API for the LfK! runner system.",
+                title: "LfK! Backend API",
+                version: process.env.npm_package_version
+            },
+        }
+    );
+}
--- a/src/controllers/AuthController.ts
+++ b/src/controllers/AuthController.ts
@@ -2,12 +2,12 @@ import { Body, CookieParam, JsonController, Param, Post, Req, Res } from 'routin
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { IllegalJWTError, InvalidCredentialsError, JwtNotProvidedError, PasswordNeededError, RefreshTokenCountInvalidError, UsernameOrEmailNeededError } from '../errors/AuthError';
 import { UserNotFoundError } from '../errors/UserErrors';
-import { CreateAuth } from '../models/actions/CreateAuth';
-import { CreateResetToken } from '../models/actions/CreateResetToken';
+import { CreateAuth } from '../models/actions/create/CreateAuth';
+import { CreateResetToken } from '../models/actions/create/CreateResetToken';
 import { HandleLogout } from '../models/actions/HandleLogout';
 import { RefreshAuth } from '../models/actions/RefreshAuth';
 import { ResetPassword } from '../models/actions/ResetPassword';
-import { Auth } from '../models/responses/ResponseAuth';
+import { ResponseAuth } from '../models/responses/ResponseAuth';
 import { Logout } from '../models/responses/ResponseLogout';

@JsonController('/auth')
@@ -16,7 +16,7 @@ export class AuthController {
 	}

 	@Post("/login")
-	@ResponseSchema(Auth)
+	@ResponseSchema(ResponseAuth)
 	@ResponseSchema(InvalidCredentialsError)
 	@ResponseSchema(UserNotFoundError)
 	@ResponseSchema(UsernameOrEmailNeededError)
@@ -60,7 +60,7 @@ export class AuthController {
 	}

 	@Post("/refresh")
-	@ResponseSchema(Auth)
+	@ResponseSchema(ResponseAuth)
 	@ResponseSchema(JwtNotProvidedError)
 	@ResponseSchema(IllegalJWTError)
 	@ResponseSchema(UserNotFoundError)
@@ -82,7 +82,7 @@ export class AuthController {
 	}

 	@Post("/reset")
-	@ResponseSchema(Auth)
+	@ResponseSchema(ResponseAuth)
 	@ResponseSchema(UserNotFoundError)
 	@ResponseSchema(UsernameOrEmailNeededError)
 	@OpenAPI({ description: "Request a password reset token. <br> This will provide you with a reset token that you can use by posting to /api/auth/reset/{token}." })
@@ -92,7 +92,7 @@ export class AuthController {
 	}

 	@Post("/reset/:token")
-	@ResponseSchema(Auth)
+	@ResponseSchema(ResponseAuth)
 	@ResponseSchema(UserNotFoundError)
 	@ResponseSchema(UsernameOrEmailNeededError)
 	@OpenAPI({ description: "Reset a user's utilising a valid password reset token. <br> This will set the user's password to the one you provided in the body. <br> To get a reset token post to /api/auth/reset with your username." })
--- a/src/controllers/DonorController.ts
+++ b/src/controllers/DonorController.ts
@@ -2,8 +2,8 @@ import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { DonorIdsNotMatchingError, DonorNotFoundError } from '../errors/DonorErrors';
-import { CreateDonor } from '../models/actions/CreateDonor';
-import { UpdateDonor } from '../models/actions/UpdateDonor';
+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';
@@ -52,7 +52,7 @@ export class DonorController {
 	async post(@Body({ validate: true }) createRunner: CreateDonor) {
 		let donor;
 		try {
-			donor = await createRunner.toDonor();
+			donor = await createRunner.toEntity();
 		} catch (error) {
 			throw error;
 		}
@@ -78,7 +78,7 @@ export class DonorController {
 			throw new DonorIdsNotMatchingError();
 		}

-		await this.donorRepository.save(await donor.updateDonor(oldDonor));
+		await this.donorRepository.save(await donor.update(oldDonor));
 		return new ResponseDonor(await this.donorRepository.findOne({ id: id }));
 	}

--- a/src/controllers/PermissionController.ts
+++ b/src/controllers/PermissionController.ts
@@ -3,8 +3,8 @@ import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { PermissionIdsNotMatchingError, PermissionNeedsPrincipalError, PermissionNotFoundError } from '../errors/PermissionErrors';
 import { PrincipalNotFoundError } from '../errors/PrincipalErrors';
-import { CreatePermission } from '../models/actions/CreatePermission';
-import { UpdatePermission } from '../models/actions/UpdatePermission';
+import { CreatePermission } from '../models/actions/create/CreatePermission';
+import { UpdatePermission } from '../models/actions/update/UpdatePermission';
 import { Permission } from '../models/entities/Permission';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponsePermission } from '../models/responses/ResponsePermission';
@@ -58,7 +58,7 @@ export class PermissionController {
    async post(@Body({ validate: true }) createPermission: CreatePermission) {
        let permission;
        try {
-            permission = await createPermission.toPermission();
+            permission = await createPermission.toEntity();
        } catch (error) {
            throw error;
        }
@@ -96,7 +96,7 @@ export class PermissionController {
            return new ResponsePermission(existingPermission);
        }

-        await this.permissionRepository.save(await permission.updatePermission(oldPermission));
+        await this.permissionRepository.save(await permission.update(oldPermission));

        return new ResponsePermission(await this.permissionRepository.findOne({ id: permission.id }, { relations: ['principal'] }));
    }
--- a/src/controllers/RunnerCardController.ts
+++ b/src/controllers/RunnerCardController.ts
@@ -0,0 +1,106 @@
+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 { RunnerCardHasScansError, RunnerCardIdsNotMatchingError, RunnerCardNotFoundError } from '../errors/RunnerCardErrors';
+import { RunnerNotFoundError } from '../errors/RunnerErrors';
+import { CreateRunnerCard } from '../models/actions/create/CreateRunnerCard';
+import { UpdateRunnerCard } from '../models/actions/update/UpdateRunnerCard';
+import { RunnerCard } from '../models/entities/RunnerCard';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseRunnerCard } from '../models/responses/ResponseRunnerCard';
+import { ScanController } from './ScanController';
+
+@JsonController('/cards')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class RunnerCardController {
+	private cardRepository: Repository<RunnerCard>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.cardRepository = getConnectionManager().get().getRepository(RunnerCard);
+	}
+
+	@Get()
+	@Authorized("CARD:GET")
+	@ResponseSchema(ResponseRunnerCard, { isArray: true })
+	@OpenAPI({ description: 'Lists all card.' })
+	async getAll() {
+		let responseCards: ResponseRunnerCard[] = new Array<ResponseRunnerCard>();
+		const cards = await this.cardRepository.find({ relations: ['runner'] });
+		cards.forEach(card => {
+			responseCards.push(new ResponseRunnerCard(card));
+		});
+		return responseCards;
+	}
+
+	@Get('/:id')
+	@Authorized("CARD:GET")
+	@ResponseSchema(ResponseRunnerCard)
+	@ResponseSchema(RunnerCardNotFoundError, { statusCode: 404 })
+	@OnUndefined(RunnerCardNotFoundError)
+	@OpenAPI({ description: "Lists all information about the card whose id got provided." })
+	async getOne(@Param('id') id: number) {
+		let card = await this.cardRepository.findOne({ id: id }, { relations: ['runner'] });
+		if (!card) { throw new RunnerCardNotFoundError(); }
+		return card.toResponse();
+	}
+
+	@Post()
+	@Authorized("CARD:CREATE")
+	@ResponseSchema(ResponseRunnerCard)
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: "Create a new card. <br> You can provide a associated runner by id but you don't have to." })
+	async post(@Body({ validate: true }) createCard: CreateRunnerCard) {
+		let card = await createCard.toEntity();
+		card = await this.cardRepository.save(card);
+		return (await this.cardRepository.findOne({ id: card.id }, { relations: ['runner'] })).toResponse();
+	}
+
+	@Put('/:id')
+	@Authorized("CARD:UPDATE")
+	@ResponseSchema(ResponseRunnerCard)
+	@ResponseSchema(RunnerCardNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerCardIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the card whose id you provided. <br> Scans created via this card will still be associated with the old runner. <br> Please remember that ids can't be changed." })
+	async put(@Param('id') id: number, @Body({ validate: true }) card: UpdateRunnerCard) {
+		let oldCard = await this.cardRepository.findOne({ id: id });
+
+		if (!oldCard) {
+			throw new RunnerCardNotFoundError();
+		}
+
+		if (oldCard.id != card.id) {
+			throw new RunnerCardIdsNotMatchingError();
+		}
+
+		await this.cardRepository.save(await card.update(oldCard));
+		return (await this.cardRepository.findOne({ id: id }, { relations: ['runner'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("CARD:DELETE")
+	@ResponseSchema(ResponseRunnerCard)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(RunnerCardHasScansError, { statusCode: 406 })
+	@OnUndefined(204)
+	@OpenAPI({ description: "Delete the card whose id you provided. <br> If no card with this id exists it will just return 204(no content). <br> If the card still has scans associated you have to provide the force=true query param (warning: this deletes all scans associated with by this card - please disable it instead or just remove the runner association)." })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let card = await this.cardRepository.findOne({ id: id });
+		if (!card) { return null; }
+
+		const cardScans = (await this.cardRepository.findOne({ id: id }, { relations: ["scans"] })).scans;
+		if (cardScans.length != 0 && !force) {
+			throw new RunnerCardHasScansError();
+		}
+		const scanController = new ScanController;
+		for (let scan of cardScans) {
+			await scanController.remove(scan.id, force);
+		}
+
+		await this.cardRepository.delete(card);
+		return card.toResponse();
+	}
+}
--- a/src/controllers/RunnerController.ts
+++ b/src/controllers/RunnerController.ts
@@ -3,11 +3,13 @@ import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { RunnerGroupNeededError, RunnerIdsNotMatchingError, RunnerNotFoundError } from '../errors/RunnerErrors';
 import { RunnerGroupNotFoundError } from '../errors/RunnerGroupErrors';
-import { CreateRunner } from '../models/actions/CreateRunner';
-import { UpdateRunner } from '../models/actions/UpdateRunner';
+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 { RunnerCardController } from './RunnerCardController';
+import { ScanController } from './ScanController';

@JsonController('/runners')
@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
@@ -27,7 +29,7 @@ export class RunnerController {
 	@OpenAPI({ description: 'Lists all runners from all teams/orgs. <br> This includes the runner\'s group and distance ran.' })
 	async getAll() {
 		let responseRunners: ResponseRunner[] = new Array<ResponseRunner>();
-		const runners = await this.runnerRepository.find({ relations: ['scans', 'group'] });
+		const runners = await this.runnerRepository.find({ relations: ['scans', 'group', 'scans.track', 'cards'] });
 		runners.forEach(runner => {
 			responseRunners.push(new ResponseRunner(runner));
 		});
@@ -41,7 +43,7 @@ export class RunnerController {
 	@OnUndefined(RunnerNotFoundError)
 	@OpenAPI({ description: 'Lists all information about the runner whose id got provided.' })
 	async getOne(@Param('id') id: number) {
-		let runner = await this.runnerRepository.findOne({ id: id }, { relations: ['scans', 'group'] })
+		let runner = await this.runnerRepository.findOne({ id: id }, { relations: ['scans', 'group', 'scans.track', 'cards'] })
 		if (!runner) { throw new RunnerNotFoundError(); }
 		return new ResponseRunner(runner);
 	}
@@ -55,13 +57,13 @@ export class RunnerController {
 	async post(@Body({ validate: true }) createRunner: CreateRunner) {
 		let runner;
 		try {
-			runner = await createRunner.toRunner();
+			runner = await createRunner.toEntity();
 		} catch (error) {
 			throw error;
 		}

 		runner = await this.runnerRepository.save(runner)
-		return new ResponseRunner(await this.runnerRepository.findOne(runner, { relations: ['scans', 'group'] }));
+		return new ResponseRunner(await this.runnerRepository.findOne(runner, { relations: ['scans', 'group', 'scans.track', 'cards'] }));
 	}

 	@Put('/:id')
@@ -81,8 +83,8 @@ export class RunnerController {
 			throw new RunnerIdsNotMatchingError();
 		}

-		await this.runnerRepository.save(await runner.updateRunner(oldRunner));
-		return new ResponseRunner(await this.runnerRepository.findOne({ id: id }, { relations: ['scans', 'group'] }));
+		await this.runnerRepository.save(await runner.update(oldRunner));
+		return new ResponseRunner(await this.runnerRepository.findOne({ id: id }, { relations: ['scans', 'group', 'scans.track', 'cards'] }));
 	}

 	@Delete('/:id')
@@ -90,16 +92,28 @@ export class RunnerController {
 	@ResponseSchema(ResponseRunner)
 	@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 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) {
 		let runner = await this.runnerRepository.findOne({ id: id });
 		if (!runner) { return null; }
-		const responseRunner = await this.runnerRepository.findOne(runner, { relations: ['scans', 'group'] });
+		const responseRunner = await this.runnerRepository.findOne(runner, { relations: ['scans', 'group', 'scans.track', 'cards'] });

 		if (!runner) {
 			throw new RunnerNotFoundError();
 		}

+		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);
+		}
+
+		const runnerScans = (await this.runnerRepository.findOne({ id: runner.id }, { relations: ["scans"] })).scans;
+		const scanController = new ScanController;
+		for (let scan of runnerScans) {
+			await scanController.remove(scan.id, force);
+		}
+
 		await this.runnerRepository.delete(runner);
 		return new ResponseRunner(responseRunner);
 	}
--- a/src/controllers/RunnerOrganisationController.ts
+++ b/src/controllers/RunnerOrganisationController.ts
@@ -2,8 +2,8 @@ import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { RunnerOrganisationHasRunnersError, RunnerOrganisationHasTeamsError, RunnerOrganisationIdsNotMatchingError, RunnerOrganisationNotFoundError } from '../errors/RunnerOrganisationErrors';
-import { CreateRunnerOrganisation } from '../models/actions/CreateRunnerOrganisation';
-import { UpdateRunnerOrganisation } from '../models/actions/UpdateRunnerOrganisation';
+import { CreateRunnerOrganisation } from '../models/actions/create/CreateRunnerOrganisation';
+import { UpdateRunnerOrganisation } from '../models/actions/update/UpdateRunnerOrganisation';
 import { RunnerOrganisation } from '../models/entities/RunnerOrganisation';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseRunnerOrganisation } from '../models/responses/ResponseRunnerOrganisation';
@@ -55,7 +55,7 @@ export class RunnerOrganisationController {
 	async post(@Body({ validate: true }) createRunnerOrganisation: CreateRunnerOrganisation) {
 		let runnerOrganisation;
 		try {
-			runnerOrganisation = await createRunnerOrganisation.toRunnerOrganisation();
+			runnerOrganisation = await createRunnerOrganisation.toEntity();
 		} catch (error) {
 			throw error;
 		}
@@ -82,7 +82,7 @@ export class RunnerOrganisationController {
 			throw new RunnerOrganisationIdsNotMatchingError();
 		}

-		await this.runnerOrganisationRepository.save(await updateOrganisation.updateRunnerOrganisation(oldRunnerOrganisation));
+		await this.runnerOrganisationRepository.save(await updateOrganisation.update(oldRunnerOrganisation));

 		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['address', 'contact', 'teams'] }));
 	}
--- a/src/controllers/RunnerTeamController.ts
+++ b/src/controllers/RunnerTeamController.ts
@@ -2,8 +2,8 @@ import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { RunnerTeamHasRunnersError, RunnerTeamIdsNotMatchingError, RunnerTeamNotFoundError } from '../errors/RunnerTeamErrors';
-import { CreateRunnerTeam } from '../models/actions/CreateRunnerTeam';
-import { UpdateRunnerTeam } from '../models/actions/UpdateRunnerTeam';
+import { CreateRunnerTeam } from '../models/actions/create/CreateRunnerTeam';
+import { UpdateRunnerTeam } from '../models/actions/update/UpdateRunnerTeam';
 import { RunnerTeam } from '../models/entities/RunnerTeam';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseRunnerTeam } from '../models/responses/ResponseRunnerTeam';
@@ -54,7 +54,7 @@ export class RunnerTeamController {
 	async post(@Body({ validate: true }) createRunnerTeam: CreateRunnerTeam) {
 		let runnerTeam;
 		try {
-			runnerTeam = await createRunnerTeam.toRunnerTeam();
+			runnerTeam = await createRunnerTeam.toEntity();
 		} catch (error) {
 			throw error;
 		}
@@ -82,7 +82,7 @@ export class RunnerTeamController {
 			throw new RunnerTeamIdsNotMatchingError();
 		}

-		await this.runnerTeamRepository.save(await runnerTeam.updateRunnerTeam(oldRunnerTeam));
+		await this.runnerTeamRepository.save(await runnerTeam.update(oldRunnerTeam));

 		return new ResponseRunnerTeam(await this.runnerTeamRepository.findOne({ id: runnerTeam.id }, { relations: ['parentGroup', 'contact'] }));
 	}
--- a/src/controllers/ScanController.ts
+++ b/src/controllers/ScanController.ts
@@ -0,0 +1,140 @@
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam, UseBefore } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnectionManager, Repository } from 'typeorm';
+import { RunnerNotFoundError } from '../errors/RunnerErrors';
+import { ScanIdsNotMatchingError, ScanNotFoundError } from '../errors/ScanErrors';
+import { ScanStationNotFoundError } from '../errors/ScanStationErrors';
+import ScanAuth from '../middlewares/ScanAuth';
+import { CreateScan } from '../models/actions/create/CreateScan';
+import { CreateTrackScan } from '../models/actions/create/CreateTrackScan';
+import { UpdateScan } from '../models/actions/update/UpdateScan';
+import { UpdateTrackScan } from '../models/actions/update/UpdateTrackScan';
+import { Scan } from '../models/entities/Scan';
+import { TrackScan } from '../models/entities/TrackScan';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseScan } from '../models/responses/ResponseScan';
+import { ResponseTrackScan } from '../models/responses/ResponseTrackScan';
+
+@JsonController('/scans')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class ScanController {
+	private scanRepository: Repository<Scan>;
+	private trackScanRepository: Repository<TrackScan>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.scanRepository = getConnectionManager().get().getRepository(Scan);
+		this.trackScanRepository = getConnectionManager().get().getRepository(TrackScan);
+	}
+
+	@Get()
+	@Authorized("SCAN:GET")
+	@ResponseSchema(ResponseScan, { isArray: true })
+	@ResponseSchema(ResponseTrackScan, { isArray: true })
+	@OpenAPI({ description: 'Lists all scans (normal or track) from all runners. <br> This includes the scan\'s runner\'s distance ran.' })
+	async getAll() {
+		let responseScans: ResponseScan[] = new Array<ResponseScan>();
+		const scans = await this.scanRepository.find({ relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] });
+		scans.forEach(scan => {
+			responseScans.push(scan.toResponse());
+		});
+		return responseScans;
+	}
+
+	@Get('/:id')
+	@Authorized("SCAN:GET")
+	@ResponseSchema(ResponseScan)
+	@ResponseSchema(ResponseTrackScan)
+	@ResponseSchema(ScanNotFoundError, { statusCode: 404 })
+	@OnUndefined(ScanNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the scan whose id got provided. This includes the scan\'s runner\'s distance ran.' })
+	async getOne(@Param('id') id: number) {
+		let scan = await this.scanRepository.findOne({ id: id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] })
+		if (!scan) { throw new ScanNotFoundError(); }
+		return scan.toResponse();
+	}
+
+	@Post()
+	@UseBefore(ScanAuth)
+	@ResponseSchema(ResponseScan)
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new scan (not track scan - use /scans/trackscans instead). <br> Please rmemember to provide the scan\'s runner\'s id and distance.', security: [{ "ScanApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+	async post(@Body({ validate: true }) createScan: CreateScan) {
+		let scan = await createScan.toEntity();
+		scan = await this.scanRepository.save(scan);
+		return (await this.scanRepository.findOne({ id: scan.id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] })).toResponse();
+	}
+
+	@Post("/trackscans")
+	@UseBefore(ScanAuth)
+	@ResponseSchema(ResponseTrackScan)
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new track scan (for "normal" scans use /scans instead). <br> Please remember that to provide the scan\'s card\'s station\'s id.', security: [{ "ScanApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+	async postTrackScans(@Body({ validate: true }) createScan: CreateTrackScan) {
+		let scan = await createScan.toEntity();
+		scan = await this.trackScanRepository.save(scan);
+		return (await this.scanRepository.findOne({ id: scan.id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] })).toResponse();
+	}
+
+	@Put('/:id')
+	@Authorized("SCAN:UPDATE")
+	@ResponseSchema(ResponseScan)
+	@ResponseSchema(ScanNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ScanIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the scan (not track scan use /scans/trackscans/:id instead) whose id you provided. <br> Please remember that ids can't be changed and distances must be positive." })
+	async put(@Param('id') id: number, @Body({ validate: true }) scan: UpdateScan) {
+		let oldScan = await this.scanRepository.findOne({ id: id });
+
+		if (!oldScan) {
+			throw new ScanNotFoundError();
+		}
+
+		if (oldScan.id != scan.id) {
+			throw new ScanIdsNotMatchingError();
+		}
+
+		await this.scanRepository.save(await scan.update(oldScan));
+		return (await this.scanRepository.findOne({ id: id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] })).toResponse();
+	}
+
+	@Put('/trackscans/:id')
+	@Authorized("SCAN:UPDATE")
+	@ResponseSchema(ResponseTrackScan)
+	@ResponseSchema(ScanNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ScanStationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ScanIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: 'Update the track scan (not "normal" scan use /scans/trackscans/:id instead) whose id you provided. <br> Please remember that only the validity, runner and track can be changed.' })
+	async putTrackScan(@Param('id') id: number, @Body({ validate: true }) scan: UpdateTrackScan) {
+		let oldScan = await this.trackScanRepository.findOne({ id: id });
+
+		if (!oldScan) {
+			throw new ScanNotFoundError();
+		}
+
+		if (oldScan.id != scan.id) {
+			throw new ScanIdsNotMatchingError();
+		}
+
+		await this.trackScanRepository.save(await scan.update(oldScan));
+		return (await this.scanRepository.findOne({ id: id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("SCAN:DELETE")
+	@ResponseSchema(ResponseScan)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the scan whose id you provided. <br> If no scan with this id exists it will just return 204(no content).' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let scan = await this.scanRepository.findOne({ id: id });
+		if (!scan) { return null; }
+		const responseScan = await this.scanRepository.findOne({ id: scan.id }, { relations: ['runner', 'track', 'runner.scans', 'runner.scans.track', 'card', 'station'] });
+
+		await this.scanRepository.delete(scan);
+		return responseScan.toResponse();
+	}
+}
--- a/src/controllers/ScanStationController.ts
+++ b/src/controllers/ScanStationController.ts
@@ -0,0 +1,108 @@
+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 { ScanStationHasScansError, ScanStationIdsNotMatchingError, ScanStationNotFoundError } from '../errors/ScanStationErrors';
+import { TrackNotFoundError } from '../errors/TrackErrors';
+import { CreateScanStation } from '../models/actions/create/CreateScanStation';
+import { UpdateScanStation } from '../models/actions/update/UpdateScanStation';
+import { ScanStation } from '../models/entities/ScanStation';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseScanStation } from '../models/responses/ResponseScanStation';
+import { ScanController } from './ScanController';
+
+@JsonController('/stations')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class ScanStationController {
+	private stationRepository: Repository<ScanStation>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.stationRepository = getConnectionManager().get().getRepository(ScanStation);
+	}
+
+	@Get()
+	@Authorized("STATION:GET")
+	@ResponseSchema(ResponseScanStation, { isArray: true })
+	@OpenAPI({ description: 'Lists all stations. <br> This includes their associated tracks.' })
+	async getAll() {
+		let responseStations: ResponseScanStation[] = new Array<ResponseScanStation>();
+		const stations = await this.stationRepository.find({ relations: ['track'] });
+		stations.forEach(station => {
+			responseStations.push(station.toResponse());
+		});
+		return responseStations;
+	}
+
+	@Get('/:id')
+	@Authorized("STATION:GET")
+	@ResponseSchema(ResponseScanStation)
+	@ResponseSchema(ScanStationNotFoundError, { statusCode: 404 })
+	@OnUndefined(ScanStationNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the station whose id got provided. <br> This includes it\'s associated track.' })
+	async getOne(@Param('id') id: number) {
+		let scan = await this.stationRepository.findOne({ id: id }, { relations: ['track'] })
+		if (!scan) { throw new ScanStationNotFoundError(); }
+		return scan.toResponse();
+	}
+
+	@Post()
+	@Authorized("STATION:CREATE")
+	@ResponseSchema(ResponseScanStation)
+	@ResponseSchema(TrackNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new station. <br> Please remeber to provide the station\'s track\'s id. <br> Please also remember that the station key is only visibe on creation.' })
+	async post(@Body({ validate: true }) createStation: CreateScanStation) {
+		let newStation = await createStation.toEntity();
+		const station = await this.stationRepository.save(newStation);
+		let responseStation = (await this.stationRepository.findOne({ id: station.id }, { relations: ['track'] })).toResponse();
+		responseStation.key = newStation.cleartextkey;
+		return responseStation;
+	}
+
+	@Put('/:id')
+	@Authorized("STATION:UPDATE")
+	@ResponseSchema(ResponseScanStation)
+	@ResponseSchema(ScanStationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ScanStationIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the station whose id you provided. <br> Please remember that only the description and enabled state can be changed." })
+	async put(@Param('id') id: number, @Body({ validate: true }) station: UpdateScanStation) {
+		let oldStation = await this.stationRepository.findOne({ id: id });
+
+		if (!oldStation) {
+			throw new ScanStationNotFoundError();
+		}
+
+		if (oldStation.id != station.id) {
+			throw new ScanStationIdsNotMatchingError();
+		}
+
+		await this.stationRepository.save(await station.update(oldStation));
+		return (await this.stationRepository.findOne({ id: id }, { relations: ['track'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("STATION:DELETE")
+	@ResponseSchema(ResponseScanStation)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(ScanStationHasScansError, { statusCode: 406 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the station whose id you provided. <br> If no station with this id exists it will just return 204(no content). <br> If the station still has scans associated you have to provide the force=true query param (warning: this deletes all scans associated with/created by this station - please disable it instead).' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let station = await this.stationRepository.findOne({ id: id });
+		if (!station) { return null; }
+
+		const stationScans = (await this.stationRepository.findOne({ id: station.id }, { relations: ["scans"] })).scans;
+		if (stationScans.length != 0 && !force) {
+			throw new ScanStationHasScansError();
+		}
+		const scanController = new ScanController;
+		for (let scan of stationScans) {
+			await scanController.remove(scan.id, force);
+		}
+
+		const responseStation = await this.stationRepository.findOne({ id: station.id }, { relations: ["track"] });
+		await this.stationRepository.delete(station);
+		return responseStation.toResponse();
+	}
+}
--- a/src/controllers/StatsClientController.ts
+++ b/src/controllers/StatsClientController.ts
@@ -1,9 +1,9 @@
-import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post } from 'routing-controllers';
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, QueryParam } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { StatsClientNotFoundError } from '../errors/StatsClientErrors';
 import { TrackNotFoundError } from "../errors/TrackErrors";
-import { CreateStatsClient } from '../models/actions/CreateStatsClient';
+import { CreateStatsClient } from '../models/actions/create/CreateStatsClient';
 import { StatsClient } from '../models/entities/StatsClient';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseStatsClient } from '../models/responses/ResponseStatsClient';
@@ -53,7 +53,7 @@ export class StatsClientController {
 		@Body({ validate: true })
 		client: CreateStatsClient
 	) {
-		let newClient = await this.clientRepository.save(await client.toStatsClient());
+		let newClient = await this.clientRepository.save(await client.toEntity());
 		let responseClient = new ResponseStatsClient(newClient);
 		responseClient.key = newClient.cleartextkey;
 		return responseClient;
@@ -65,7 +65,7 @@ export class StatsClientController {
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@OnUndefined(204)
 	@OpenAPI({ description: "Delete the stats client whose id you provided. <br> If no client with this id exists it will just return 204(no content)." })
-	async remove(@Param("id") id: number) {
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let client = await this.clientRepository.findOne({ id: id });
 		if (!client) { return null; }

--- a/src/controllers/TrackController.ts
+++ b/src/controllers/TrackController.ts
@@ -1,12 +1,13 @@
-import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers';
+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 { TrackIdsNotMatchingError, TrackLapTimeCantBeNegativeError, TrackNotFoundError } from "../errors/TrackErrors";
-import { CreateTrack } from '../models/actions/CreateTrack';
-import { UpdateTrack } from '../models/actions/UpdateTrack';
+import { TrackHasScanStationsError, TrackIdsNotMatchingError, TrackLapTimeCantBeNegativeError, TrackNotFoundError } from "../errors/TrackErrors";
+import { CreateTrack } from '../models/actions/create/CreateTrack';
+import { UpdateTrack } from '../models/actions/update/UpdateTrack';
 import { Track } from '../models/entities/Track';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseTrack } from '../models/responses/ResponseTrack';
+import { ScanStationController } from './ScanStationController';

@JsonController('/tracks')
@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
@@ -54,7 +55,7 @@ export class TrackController {
 		@Body({ validate: true })
 		track: CreateTrack
 	) {
-		return new ResponseTrack(await this.trackRepository.save(track.toTrack()));
+		return new ResponseTrack(await this.trackRepository.save(await track.toEntity()));
 	}

 	@Put('/:id')
@@ -74,7 +75,7 @@ export class TrackController {
 		if (oldTrack.id != updateTrack.id) {
 			throw new TrackIdsNotMatchingError();
 		}
-		await this.trackRepository.save(await updateTrack.updateTrack(oldTrack));
+		await this.trackRepository.save(await updateTrack.update(oldTrack));

 		return new ResponseTrack(await this.trackRepository.findOne({ id: id }));
 	}
@@ -85,10 +86,19 @@ export class TrackController {
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@OnUndefined(204)
 	@OpenAPI({ description: "Delete the track whose id you provided. <br> If no track with this id exists it will just return 204(no content)." })
-	async remove(@Param("id") id: number) {
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let track = await this.trackRepository.findOne({ id: id });
 		if (!track) { return null; }

+		const trackStations = (await this.trackRepository.findOne({ id: id }, { relations: ["stations"] })).stations;
+		if (trackStations.length != 0 && !force) {
+			throw new TrackHasScanStationsError();
+		}
+		const stationController = new ScanStationController;
+		for (let station of trackStations) {
+			await stationController.remove(station.id, force);
+		}
+
 		await this.trackRepository.delete(track);
 		return new ResponseTrack(track);
 	}
--- a/src/controllers/UserController.ts
+++ b/src/controllers/UserController.ts
@@ -3,8 +3,8 @@ import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { UserIdsNotMatchingError, UserNotFoundError } from '../errors/UserErrors';
 import { UserGroupNotFoundError } from '../errors/UserGroupErrors';
-import { CreateUser } from '../models/actions/CreateUser';
-import { UpdateUser } from '../models/actions/UpdateUser';
+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';
@@ -25,11 +25,11 @@ export class UserController {

 	@Get()
 	@Authorized("USER:GET")
-	@ResponseSchema(User, { isArray: true })
+	@ResponseSchema(ResponseUser, { isArray: true })
 	@OpenAPI({ description: 'Lists all users. <br> This includes their groups and permissions directly granted to them (if existing/associated).' })
 	async getAll() {
 		let responseUsers: ResponseUser[] = new Array<ResponseUser>();
-		const users = await this.userRepository.find({ relations: ['permissions', 'groups'] });
+		const users = await this.userRepository.find({ relations: ['permissions', 'groups', 'groups.permissions'] });
 		users.forEach(user => {
 			responseUsers.push(new ResponseUser(user));
 		});
@@ -38,25 +38,25 @@ export class UserController {

 	@Get('/:id')
 	@Authorized("USER:GET")
-	@ResponseSchema(User)
+	@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.' })
 	async getOne(@Param('id') id: number) {
-		let user = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups'] })
+		let user = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions'] })
 		if (!user) { throw new UserNotFoundError(); }
 		return new ResponseUser(user);
 	}

 	@Post()
 	@Authorized("USER:CREATE")
-	@ResponseSchema(User)
+	@ResponseSchema(ResponseUser)
 	@ResponseSchema(UserGroupNotFoundError)
 	@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;
 		try {
-			user = await createUser.toUser();
+			user = await createUser.toEntity();
 		} catch (error) {
 			throw error;
 		}
@@ -67,7 +67,7 @@ export class UserController {

 	@Put('/:id')
 	@Authorized("USER:UPDATE")
-	@ResponseSchema(User)
+	@ResponseSchema(ResponseUser)
 	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
 	@ResponseSchema(UserIdsNotMatchingError, { 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." })
@@ -81,14 +81,14 @@ export class UserController {
 		if (oldUser.id != updateUser.id) {
 			throw new UserIdsNotMatchingError();
 		}
-		await this.userRepository.save(await updateUser.updateUser(oldUser));
+		await this.userRepository.save(await updateUser.update(oldUser));

 		return new ResponseUser(await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups'] }));
 	}

 	@Delete('/:id')
 	@Authorized("USER:DELETE")
-	@ResponseSchema(User)
+	@ResponseSchema(ResponseUser)
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@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).' })
--- a/src/controllers/UserGroupController.ts
+++ b/src/controllers/UserGroupController.ts
@@ -3,7 +3,8 @@ import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
 import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { UserGroupIdsNotMatchingError, UserGroupNotFoundError } from '../errors/UserGroupErrors';
-import { CreateUserGroup } from '../models/actions/CreateUserGroup';
+import { CreateUserGroup } from '../models/actions/create/CreateUserGroup';
+import { UpdateUserGroup } from '../models/actions/update/UpdateUserGroup';
 import { UserGroup } from '../models/entities/UserGroup';
 import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseUserGroup } from '../models/responses/ResponseUserGroup';
@@ -48,7 +49,7 @@ export class UserGroupController {
 	async post(@Body({ validate: true }) createUserGroup: CreateUserGroup) {
 		let userGroup;
 		try {
-			userGroup = await createUserGroup.toUserGroup();
+			userGroup = await createUserGroup.toEntity();
 		} catch (error) {
 			throw error;
 		}
@@ -62,19 +63,19 @@ export class UserGroupController {
 	@ResponseSchema(UserGroupNotFoundError, { statusCode: 404 })
 	@ResponseSchema(UserGroupIdsNotMatchingError, { statusCode: 406 })
 	@OpenAPI({ description: "Update the group whose id you provided. <br> To change the permissions granted to the group please use /api/permissions instead. <br> Please remember that ids can't be changed." })
-	async put(@Param('id') id: number, @EntityFromBody() userGroup: UserGroup) {
-		let oldUserGroup = await this.userGroupsRepository.findOne({ id: id }, { relations: ["permissions"] });
+	async put(@Param('id') id: number, @EntityFromBody() updateGroup: UpdateUserGroup) {
+		let oldGroup = await this.userGroupsRepository.findOne({ id: id });

-		if (!oldUserGroup) {
-			throw new UserGroupNotFoundError()
+		if (!oldGroup) {
+			throw new UserGroupNotFoundError();
 		}

-		if (oldUserGroup.id != userGroup.id) {
+		if (oldGroup.id != updateGroup.id) {
 			throw new UserGroupIdsNotMatchingError();
 		}
+		await this.userGroupsRepository.save(await updateGroup.update(oldGroup));

-		await this.userGroupsRepository.save(userGroup);
-		return userGroup;
+		return (await this.userGroupsRepository.findOne({ id: id }, { relations: ['permissions', 'groups'] })).toResponse();
 	}

 	@Delete('/:id')
@@ -88,9 +89,9 @@ export class UserGroupController {
 		if (!group) { return null; }
 		const responseGroup = await this.userGroupsRepository.findOne({ id: id }, { relations: ['permissions'] });

-		const permissionControler = new PermissionController();
+		const permissionController = new PermissionController();
 		for (let permission of responseGroup.permissions) {
-			await permissionControler.remove(permission.id, true);
+			await permissionController.remove(permission.id, true);
 		}

 		await this.userGroupsRepository.delete(group);
--- a/src/errors/AddressErrors.ts
+++ b/src/errors/AddressErrors.ts
@@ -9,11 +9,11 @@ export class AddressWrongTypeError extends NotAcceptableError {
 	name = "AddressWrongTypeError"

 	@IsString()
-	message = "The address must be an existing adress's id. \n You provided a object of another type."
+	message = "The address must be an existing address's id. \n You provided a object of another type."
 }

 /**
- * Error to throw, when a non-existant address get's loaded.
+ * Error to throw, when a non-existent address get's loaded.
 */
 export class AddressNotFoundError extends NotFoundError {
 	@IsString()
--- a/src/errors/AuthError.ts
+++ b/src/errors/AuthError.ts
@@ -118,7 +118,7 @@ export class RefreshTokenCountInvalidError extends NotAcceptableError {
 }

 /**
- * Error to throw when someone tryes to reset a user's password more than once in 15 minutes.
+ * Error to throw when someone tries to reset a user's password more than once in 15 minutes.
 */
 export class ResetAlreadyRequestedError extends NotAcceptableError {
 	@IsString()
--- a/src/errors/GroupContactErrors.ts
+++ b/src/errors/GroupContactErrors.ts
@@ -13,7 +13,7 @@ export class GroupContactWrongTypeError extends NotAcceptableError {
 }

 /**
- * Error to throw, when a non-existant groupContact get's loaded.
+ * Error to throw, when a non-existent groupContact get's loaded.
 */
 export class GroupContactNotFoundError extends NotFoundError {
 	@IsString()
--- a/src/errors/PrincipalErrors.ts
+++ b/src/errors/PrincipalErrors.ts
@@ -13,12 +13,12 @@ export class PrincipalNotFoundError extends NotFoundError {
 }

 /**
- * Error to throw, when a provided runnerOrganisation doesn't belong to the accepted types.
+ * Error to throw, when a provided runner organization doesn't belong to the accepted types.
 */
 export class PrincipalWrongTypeError extends NotAcceptableError {
 	@IsString()
 	name = "PrincipalWrongTypeError"

 	@IsString()
-	message = "The princial must have an existing principal's id. \n You provided a object of another type."
+	message = "The principal must have an existing principal's id. \n You provided a object of another type."
 }
--- a/src/errors/RunnerCardErrors.ts
+++ b/src/errors/RunnerCardErrors.ts
@@ -0,0 +1,48 @@
+import { IsString } from 'class-validator';
+import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+
+/**
+ * Error to throw when a card couldn't be found.
+ */
+export class RunnerCardNotFoundError extends NotFoundError {
+	@IsString()
+	name = "RunnerCardNotFoundError"
+
+	@IsString()
+	message = "Card not found!"
+}
+
+/**
+ * Error to throw when two cards' ids don't match.
+ * Usually occurs when a user tries to change a card's id.
+ */
+export class RunnerCardIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerCardIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a cards's id: This isn't allowed"
+}
+
+/**
+ * Error to throw when a card still has scans associated.
+ */
+export class RunnerCardHasScansError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerCardHasScansError"
+
+	@IsString()
+	message = "This card still has scans associated with it. \n If you want to delete this card with all it's scans add `?force` to your query. \n Otherwise please consider just disabling it."
+}
+
+/**
+ * Error to throw when a card's id is too big to generate a ean-13 barcode for it.
+ * This error should never reach a end user.
+ */
+export class RunnerCardIdOutOfRangeError extends Error {
+	@IsString()
+	name = "RunnerCardIdOutOfRangeError"
+
+	@IsString()
+	message = "The card's id is too big to fit into a ean-13 barcode. \n This has a very low probability of happening but means that you might want to switch your barcode format for something that can accept numbers over 9999999999."
+}
--- a/src/errors/RunnerErrors.ts
+++ b/src/errors/RunnerErrors.ts
@@ -32,5 +32,5 @@ export class RunnerGroupNeededError extends NotAcceptableError {
 	name = "RunnerGroupNeededError"

 	@IsString()
-	message = "Runner's need to be part of one group (team or organisiation)! \n You provided neither."
+	message = "Runner's need to be part of one group (team or organisation)! \n You provided neither."
 }
--- a/src/errors/RunnerOrganisationErrors.ts
+++ b/src/errors/RunnerOrganisationErrors.ts
@@ -13,7 +13,7 @@ export class RunnerOrganisationNotFoundError extends NotFoundError {
 }

 /**
- * Error to throw when two runner organisations' ids don't match.
+ * Error to throw when two runner organisation's ids don't match.
 * Usually occurs when a user tries to change a runner organisation's id.
 */
 export class RunnerOrganisationIdsNotMatchingError extends NotAcceptableError {
--- a/src/errors/ScanErrors.ts
+++ b/src/errors/ScanErrors.ts
@@ -0,0 +1,25 @@
+import { IsString } from 'class-validator';
+import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+
+/**
+ * Error to throw when a Scan couldn't be found.
+ */
+export class ScanNotFoundError extends NotFoundError {
+	@IsString()
+	name = "ScanNotFoundError"
+
+	@IsString()
+	message = "Scan not found!"
+}
+
+/**
+ * Error to throw when two Scans' ids don't match.
+ * Usually occurs when a user tries to change a Scan's id.
+ */
+export class ScanIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "ScanIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a Scan's id: This isn't allowed!"
+}
--- a/src/errors/ScanStationErrors.ts
+++ b/src/errors/ScanStationErrors.ts
@@ -0,0 +1,36 @@
+import { IsString } from 'class-validator';
+import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+
+/**
+ * Error to throw, when a non-existent scan station get's loaded.
+ */
+export class ScanStationNotFoundError extends NotFoundError {
+	@IsString()
+	name = "ScanStationNotFoundError"
+
+	@IsString()
+	message = "The scan station you provided couldn't be located in the system. \n Please check your request."
+}
+
+/**
+ * Error to throw when two scan stations' ids don't match.
+ * Usually occurs when a user tries to change a scan station's id.
+ */
+export class ScanStationIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "ScanStationIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a scan station's id: This isn't allowed!"
+}
+
+/**
+ * Error to throw when a station still has scans associated.
+ */
+export class ScanStationHasScansError extends NotAcceptableError {
+	@IsString()
+	name = "ScanStationHasScansError"
+
+	@IsString()
+	message = "This station still has scans associated with it. \n If you want to delete this station with all it's scans add `?force` to your query."
+}
--- a/src/errors/StatsClientErrors.ts
+++ b/src/errors/StatsClientErrors.ts
@@ -2,7 +2,7 @@ import { IsString } from 'class-validator';
 import { NotAcceptableError, NotFoundError } from 'routing-controllers';

 /**
- * Error to throw, when a non-existant stats client get's loaded.
+ * Error to throw, when a non-existent stats client get's loaded.
 */
 export class StatsClientNotFoundError extends NotFoundError {
 	@IsString()
--- a/src/errors/TrackErrors.ts
+++ b/src/errors/TrackErrors.ts
@@ -33,4 +33,12 @@ export class TrackLapTimeCantBeNegativeError extends NotAcceptableError {

 	@IsString()
 	message = "The minimum lap time you provided is negative - That isn't possible. \n If you wanted to disable it: Just set it to 0/null."
+}
+
+export class TrackHasScanStationsError extends NotAcceptableError {
+	@IsString()
+	name = "TrackHasScanStationsError"
+
+	@IsString()
+	message = "This track still has stations associated with it. \n If you want to delete this track with all it's stations and scans add `?force` to your query."
 }
--- a/src/errors/UserGroupErrors.ts
+++ b/src/errors/UserGroupErrors.ts
@@ -2,7 +2,7 @@ import { IsString } from 'class-validator';
 import { NotAcceptableError, NotFoundError } from 'routing-controllers';

 /**
- * Error to throw when no groupname is set.
+ * Error to throw when no group name is set.
 */
 export class GroupNameNeededError extends NotFoundError {
 	@IsString()
@@ -13,7 +13,7 @@ export class GroupNameNeededError extends NotFoundError {
 }

 /**
- * Error to throw when a usergroup couldn't be found.
+ * Error to throw when a user group couldn't be found.
 */
 export class UserGroupNotFoundError extends NotFoundError {
 	@IsString()
@@ -24,13 +24,13 @@ export class UserGroupNotFoundError extends NotFoundError {
 }

 /**
- * Error to throw when two usergroups' ids don't match.
- * Usually occurs when a user tries to change a usergroups's id.
+ * Error to throw when two user groups' ids don't match.
+ * Usually occurs when a user tries to change a user groups's id.
 */
 export class UserGroupIdsNotMatchingError extends NotAcceptableError {
 	@IsString()
 	name = "UserGroupIdsNotMatchingError"

 	@IsString()
-	message = "The ids don't match!! \n If you wanted to change a usergroup's id: This isn't allowed!"
+	message = "The ids don't match!! \n If you wanted to change a user group's id: This isn't allowed!"
 }
--- a/src/jwtcreator.ts
+++ b/src/jwtcreator.ts
@@ -106,23 +106,6 @@ export class JwtUser {
        this.refreshTokenCount = user.refreshTokenCount;
        this.uuid = user.uuid;
        this.profilePic = user.profilePic;
-        this.permissions = this.getPermissions(user);
-    }
-
-    /**
-     * Handels getting the permissions granted to this user (direct or indirect).
-     * @param user User which's permissions shall be gotten.
-     */
-    public getPermissions(user: User): string[] {
-        let returnPermissions: string[] = new Array<string>();
-        for (let permission of user.permissions) {
-            returnPermissions.push(permission.toString());
-        }
-        for (let group of user.groups) {
-            for (let permission of group.permissions) {
-                returnPermissions.push(permission.toString());
-            }
-        }
-        return Array.from(new Set(returnPermissions));
+        this.permissions = user.allPermissions;
    }
 }
--- a/src/loaders/openapi.ts
+++ b/src/loaders/openapi.ts
@@ -2,7 +2,7 @@ import { validationMetadatasToSchemas } from "class-validator-jsonschema";
 import express, { Application } from "express";
 import path from 'path';
 import { getMetadataArgsStorage } from "routing-controllers";
-import { routingControllersToSpec } from "routing-controllers-openapi";
+import { generateSpec } from '../apispec';

 /**
 * Loader for everything openapi related - from creating the schema to serving it via a static route and swaggerUiExpress.
@@ -15,41 +15,7 @@ export default async (app: Application) => {
  });

  //Spec creation based on the previously created schemas
-  const spec = routingControllersToSpec(
-    storage,
-    {
-      routePrefix: "/api"
-    },
-    {
-      components: {
-        schemas,
-        "securitySchemes": {
-          "AuthToken": {
-            "type": "http",
-            "scheme": "bearer",
-            "bearerFormat": "JWT",
-            description: "A JWT based access token. Use /api/auth/login or /api/auth/refresh to get one."
-          },
-          "RefreshTokenCookie": {
-            "type": "apiKey",
-            "in": "cookie",
-            "name": "lfk_backend__refresh_token",
-            description: "A cookie containing a JWT based refreh token. Attention: Doesn't work in swagger-ui. Use /api/auth/login or /api/auth/refresh to get one."
-          },
-          "StatsApiToken": {
-            "type": "http",
-            "scheme": "bearer",
-            description: "Api token that can be obtained by creating a new stats client (post to /api/statsclients)."
-          }
-        }
-      },
-      info: {
-        description: "The the backend API for the LfK! runner system.",
-        title: "LfK! Backend API",
-        version: "0.0.8",
-      },
-    }
-  );
+  const spec = generateSpec(storage, schemas);
  app.get(["/api/docs/openapi.json", "/api/docs/swagger.json"], (req, res) => {
    res.json(spec);
  });
--- a/src/middlewares/RawBody.ts
+++ b/src/middlewares/RawBody.ts
@@ -1,8 +1,8 @@
 import { Request, Response } from 'express';

 /**
- * Custom express middleware that appends the raw body to the request obeject.
- * Mainly used for parsing csvs from boddies.
+ * Custom express middleware that appends the raw body to the request object.
+ * Mainly used for parsing csvs from bodies.
 */

 const RawBodyMiddleware = (req: Request, res: Response, next: () => void) => {
--- a/src/middlewares/ScanAuth.ts
+++ b/src/middlewares/ScanAuth.ts
@@ -0,0 +1,69 @@
+import * as argon2 from "argon2";
+import { Request, Response } from 'express';
+import { getConnectionManager } from 'typeorm';
+import { ScanStation } from '../models/entities/ScanStation';
+import authchecker from './authchecker';
+
+/**
+ * This middleware handles the authentication of scan station api tokens.
+ * The tokens have to be provided via Bearer authorization header.
+ * You have to manually use this middleware via @UseBefore(ScanAuth) instead of using @Authorized().
+ * @param req Express request object.
+ * @param res Express response object.
+ * @param next Next function to call on success.
+ */
+const ScanAuth = async (req: Request, res: Response, next: () => void) => {
+    let provided_token: string = req.headers["authorization"];
+    if (provided_token == "" || provided_token === undefined || provided_token === null) {
+        res.status(401).send("No api token provided.");
+        return;
+    }
+
+    try {
+        provided_token = provided_token.replace("Bearer ", "");
+    } catch (error) {
+        res.status(401).send("No valid jwt or api token provided.");
+        return;
+    }
+
+    let prefix = "";
+    try {
+        prefix = provided_token.split(".")[0];
+    }
+    finally {
+        if (prefix == "" || prefix == undefined || prefix == null) {
+            res.status(401).send("Api token non-existent or invalid syntax.");
+            return;
+        }
+    }
+
+    const station = await getConnectionManager().get().getRepository(ScanStation).findOne({ prefix: prefix });
+    if (!station) {
+        let user_authorized = false;
+        try {
+            let action = { request: req, response: res, context: null, next: next }
+            user_authorized = await authchecker(action, ["SCAN:CREATE"]);
+        }
+        finally {
+            if (user_authorized == false) {
+                res.status(401).send("Api token non-existent or invalid syntax.");
+                return;
+            }
+            else {
+                next();
+            }
+        }
+    }
+    else {
+        if (station.enabled == false) {
+            res.status(401).send("Station disabled.");
+        }
+        if (!(await argon2.verify(station.key, provided_token))) {
+            res.status(401).send("Api token invalid.");
+            return;
+        }
+
+        next();
+    }
+}
+export default ScanAuth;
--- a/src/middlewares/StatsAuth.ts
+++ b/src/middlewares/StatsAuth.ts
@@ -5,8 +5,9 @@ import { StatsClient } from '../models/entities/StatsClient';
 import authchecker from './authchecker';

 /**
- * This middleware handels the authentification of stats client api tokens.
- * The tokens have to be provided via Bearer auth header.
+ * This middleware handles the authentication of stats client api tokens.
+ * The tokens have to be provided via Bearer authorization header.
+ * You have to manually use this middleware via @UseBefore(StatsAuth) instead of using @Authorized().
 * @param req Express request object.
 * @param res Express response object.
 * @param next Next function to call on success.
--- a/src/middlewares/authchecker.ts
+++ b/src/middlewares/authchecker.ts
@@ -8,7 +8,7 @@ import { JwtCreator, JwtUser } from '../jwtcreator';
 import { User } from '../models/entities/User';

 /**
- * Handels authorisation verification via jwt's for all api endpoints using the @Authorized decorator.
+ * Handles authentication via jwt's (Bearer authorization header) for all api endpoints using the @Authorized decorator.
 * @param action Routing-Controllers action object that provides request and response objects among other stuff.
 * @param permissions The permissions that the endpoint using @Authorized requires.
 */
@@ -43,7 +43,7 @@ const authchecker = async (action: Action, permissions: string[] | string) => {
 }

 /**
- * Handels soft-refreshing of access-tokens.
+ * 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) => {
--- a/src/models/actions/ImportRunner.ts
+++ b/src/models/actions/ImportRunner.ts
@@ -5,7 +5,7 @@ import { RunnerOrganisationNotFoundError } from '../../errors/RunnerOrganisation
 import { RunnerGroup } from '../entities/RunnerGroup';
 import { RunnerOrganisation } from '../entities/RunnerOrganisation';
 import { RunnerTeam } from '../entities/RunnerTeam';
-import { CreateRunner } from './CreateRunner';
+import { CreateRunner } from './create/CreateRunner';

 /**
 * Special class used to import runners from csv files - or json arrays created from csv to be exact.
--- a/src/models/actions/RefreshAuth.ts
+++ b/src/models/actions/RefreshAuth.ts
@@ -5,7 +5,7 @@ import { config } from '../../config';
 import { IllegalJWTError, JwtNotProvidedError, RefreshTokenCountInvalidError, UserDisabledError, UserNotFoundError } from '../../errors/AuthError';
 import { JwtCreator } from "../../jwtcreator";
 import { User } from '../entities/User';
-import { Auth } from '../responses/ResponseAuth';
+import { ResponseAuth } from '../responses/ResponseAuth';

 /**
 * This class is used to create refreshed auth credentials.
@@ -24,8 +24,8 @@ export class RefreshAuth {
    /**
     * Creates a new auth object based on this.
     */
-    public async toAuth(): Promise<Auth> {
-        let newAuth: Auth = new Auth();
+    public async toAuth(): Promise<ResponseAuth> {
+        let newAuth: ResponseAuth = new ResponseAuth();
        if (!this.token || this.token === undefined) {
            throw new JwtNotProvidedError()
        }
--- a/src/models/actions/create/CreateAddress.ts
+++ b/src/models/actions/create/CreateAddress.ts
@@ -1,6 +1,6 @@
 import { IsNotEmpty, IsOptional, IsPostalCode, IsString } from 'class-validator';
-import { config } from '../../config';
-import { Address } from '../entities/Address';
+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).
@@ -56,7 +56,7 @@ export class CreateAddress {
    /**
     * Creates a new Address entity from this.
     */
-    public toAddress(): Address {
+    public async toEntity(): Promise<Address> {
        let newAddress: Address = new Address();

        newAddress.address1 = this.address1;
--- a/src/models/actions/create/CreateAuth.ts
+++ b/src/models/actions/create/CreateAuth.ts
@@ -1,11 +1,11 @@
 import * as argon2 from "argon2";
 import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { InvalidCredentialsError, PasswordNeededError, UserDisabledError, UserNotFoundError } from '../../errors/AuthError';
-import { UsernameOrEmailNeededError } from '../../errors/UserErrors';
-import { JwtCreator } from '../../jwtcreator';
-import { User } from '../entities/User';
-import { Auth } from '../responses/ResponseAuth';
+import { InvalidCredentialsError, PasswordNeededError, UserDisabledError, UserNotFoundError } from '../../../errors/AuthError';
+import { UsernameOrEmailNeededError } from '../../../errors/UserErrors';
+import { JwtCreator } from '../../../jwtcreator';
+import { User } from '../../entities/User';
+import { ResponseAuth } from '../../responses/ResponseAuth';

 /**
 * This class is used to create auth credentials based on user credentials provided in a json body (post request).
@@ -42,8 +42,8 @@ export class CreateAuth {
    /**
     * Creates a new auth object based on this.
     */
-    public async toAuth(): Promise<Auth> {
-        let newAuth: Auth = new Auth();
+    public async toAuth(): Promise<ResponseAuth> {
+        let newAuth: ResponseAuth = new ResponseAuth();

        if (this.email === undefined && this.username === undefined) {
            throw new UsernameOrEmailNeededError();
--- a/src/models/actions/create/CreateDonor.ts
+++ b/src/models/actions/create/CreateDonor.ts
@@ -1,6 +1,6 @@
 import { IsBoolean, IsOptional } from 'class-validator';
-import { DonorReceiptAddressNeededError } from '../../errors/DonorErrors';
-import { Donor } from '../entities/Donor';
+import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
+import { Donor } from '../../entities/Donor';
 import { CreateParticipant } from './CreateParticipant';

 /**
@@ -18,7 +18,7 @@ export class CreateDonor extends CreateParticipant {
    /**
     * Creates a new Donor entity from this.
     */
-    public async toDonor(): Promise<Donor> {
+    public async toEntity(): Promise<Donor> {
        let newDonor: Donor = new Donor();

        newDonor.firstname = this.firstname;
--- a/src/models/actions/create/CreateGroupContact.ts
+++ b/src/models/actions/create/CreateGroupContact.ts
@@ -1,85 +1,85 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
-import { config } from '../../config';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../errors/AddressErrors';
-import { Address } from '../entities/Address';
-import { GroupContact } from '../entities/GroupContact';
-
-/**
- * This classed is used to create a new Group entity from a json body (post request).
- */
-export class CreateGroupContact {
-    /**
-     * The new contact's first name.
-     */
-    @IsNotEmpty()
-    @IsString()
-    firstname: string;
-
-    /**
-     * The new contact's middle name.
-     */
-    @IsOptional()
-    @IsString()
-    middlename?: string;
-
-    /**
-     * The new contact's last name.
-     */
-    @IsNotEmpty()
-    @IsString()
-    lastname: string;
-
-    /**
-     * The new contact's address.
-     * Must be the address's id.
-     */
-    @IsInt()
-    @IsOptional()
-    address?: number;
-
-    /**
-     * The 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 contact's email address.
-     */
-    @IsOptional()
-    @IsEmail()
-    email?: string;
-
-    /**
-     * Gets the new contact'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;
-    }
-
-    /**
-     * Creates a new Address entity from this.
-     */
-    public async toGroupContact(): 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;
-    }
+import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { getConnectionManager } from 'typeorm';
+import { config } from '../../../config';
+import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
+import { Address } from '../../entities/Address';
+import { GroupContact } from '../../entities/GroupContact';
+
+/**
+ * This classed is used to create a new Group entity from a json body (post request).
+ */
+export class CreateGroupContact {
+    /**
+     * The new contact's first name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    firstname: string;
+
+    /**
+     * The new contact's middle name.
+     */
+    @IsOptional()
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The new contact's last name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    lastname: string;
+
+    /**
+     * The new contact's address.
+     * Must be the address's id.
+     */
+    @IsInt()
+    @IsOptional()
+    address?: number;
+
+    /**
+     * The 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 contact's email address.
+     */
+    @IsOptional()
+    @IsEmail()
+    email?: string;
+
+    /**
+     * Gets the new contact'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;
+    }
+
+    /**
+     * Creates a new Address 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;
+    }
 }
--- a/src/models/actions/create/CreateParticipant.ts
+++ b/src/models/actions/create/CreateParticipant.ts
@@ -1,72 +1,72 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
-import { config } from '../../config';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../errors/AddressErrors';
-import { Address } from '../entities/Address';
-
-/**
- * This classed is used to create a new Participant entity from a json body (post request).
- */
-export abstract class CreateParticipant {
-    /**
-     * The new participant's first name.
-     */
-    @IsString()
-    @IsNotEmpty()
-    firstname: string;
-
-    /**
-     * The new participant's middle name.
-     */
-    @IsString()
-    @IsOptional()
-    middlename?: string;
-
-    /**
-     * The new participant's last name.
-     */
-    @IsString()
-    @IsNotEmpty()
-    lastname: string;
-
-    /**
-     * The new participant's phone number.
-     * This will be validated against the configured country phone numer syntax (default: international).
-     */
-    @IsString()
-    @IsOptional()
-    @IsPhoneNumber(config.phone_validation_countrycode)
-    phone?: string;
-
-    /**
-     * The new participant's e-mail address.
-     */
-    @IsString()
-    @IsOptional()
-    @IsEmail()
-    email?: string;
-
-    /**
-     * 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;
-    }
+import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { getConnectionManager } from 'typeorm';
+import { config } from '../../../config';
+import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
+import { Address } from '../../entities/Address';
+
+/**
+ * This classed is used to create a new Participant entity from a json body (post request).
+ */
+export abstract class CreateParticipant {
+    /**
+     * The new participant's first name.
+     */
+    @IsString()
+    @IsNotEmpty()
+    firstname: string;
+
+    /**
+     * The new participant's middle name.
+     */
+    @IsString()
+    @IsOptional()
+    middlename?: string;
+
+    /**
+     * The new participant's last name.
+     */
+    @IsString()
+    @IsNotEmpty()
+    lastname: string;
+
+    /**
+     * The new participant's phone number.
+     * This will be validated against the configured country phone numer syntax (default: international).
+     */
+    @IsString()
+    @IsOptional()
+    @IsPhoneNumber(config.phone_validation_countrycode)
+    phone?: string;
+
+    /**
+     * The new participant's e-mail address.
+     */
+    @IsString()
+    @IsOptional()
+    @IsEmail()
+    email?: string;
+
+    /**
+     * 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;
+    }
 }
--- a/src/models/actions/create/CreatePermission.ts
+++ b/src/models/actions/create/CreatePermission.ts
@@ -4,11 +4,11 @@ import {
    IsNotEmpty
 } from "class-validator";
 import { getConnectionManager } from 'typeorm';
-import { PrincipalNotFoundError } from '../../errors/PrincipalErrors';
-import { Permission } from '../entities/Permission';
-import { Principal } from '../entities/Principal';
-import { PermissionAction } from '../enums/PermissionAction';
-import { PermissionTarget } from '../enums/PermissionTargets';
+import { PrincipalNotFoundError } from '../../../errors/PrincipalErrors';
+import { Permission } from '../../entities/Permission';
+import { Principal } from '../../entities/Principal';
+import { PermissionAction } from '../../enums/PermissionAction';
+import { PermissionTarget } from '../../enums/PermissionTargets';

 /**
 * This classed is used to create a new Permission entity from a json body (post request).
@@ -39,7 +39,7 @@ export class CreatePermission {
    /**
     * Creates a new Permission entity from this.
     */
-    public async toPermission(): Promise<Permission> {
+    public async toEntity(): Promise<Permission> {
        let newPermission: Permission = new Permission();

        newPermission.principal = await this.getPrincipal();
--- a/src/models/actions/create/CreateResetToken.ts
+++ b/src/models/actions/create/CreateResetToken.ts
@@ -1,9 +1,9 @@
 import { IsEmail, IsOptional, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { ResetAlreadyRequestedError, UserDisabledError, UserNotFoundError } from '../../errors/AuthError';
-import { UsernameOrEmailNeededError } from '../../errors/UserErrors';
-import { JwtCreator } from '../../jwtcreator';
-import { User } from '../entities/User';
+import { ResetAlreadyRequestedError, UserDisabledError, UserNotFoundError } from '../../../errors/AuthError';
+import { UsernameOrEmailNeededError } from '../../../errors/UserErrors';
+import { JwtCreator } from '../../../jwtcreator';
+import { User } from '../../entities/User';

 /**
 * This calss is used to create password reset tokens for users.
--- a/src/models/actions/create/CreateRunner.ts
+++ b/src/models/actions/create/CreateRunner.ts
@@ -1,10 +1,10 @@
 import { IsInt } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerGroupNotFoundError } from '../../errors/RunnerGroupErrors';
-import { RunnerOrganisationWrongTypeError } from '../../errors/RunnerOrganisationErrors';
-import { RunnerTeamNeedsParentError } from '../../errors/RunnerTeamErrors';
-import { Runner } from '../entities/Runner';
-import { RunnerGroup } from '../entities/RunnerGroup';
+import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
+import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { Runner } from '../../entities/Runner';
+import { RunnerGroup } from '../../entities/RunnerGroup';
 import { CreateParticipant } from './CreateParticipant';

 /**
@@ -21,7 +21,7 @@ export class CreateRunner extends CreateParticipant {
    /**
     * Creates a new Runner entity from this.
     */
-    public async toRunner(): Promise<Runner> {
+    public async toEntity(): Promise<Runner> {
        let newRunner: Runner = new Runner();

        newRunner.firstname = this.firstname;
--- a/src/models/actions/create/CreateRunnerCard.ts
+++ b/src/models/actions/create/CreateRunnerCard.ts
@@ -0,0 +1,45 @@
+import { IsBoolean, IsInt, IsOptional } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { Runner } from '../../entities/Runner';
+import { RunnerCard } from '../../entities/RunnerCard';
+
+/**
+ * This classed is used to create a new RunnerCard entity from a json body (post request).
+ */
+export class CreateRunnerCard {
+    /**
+     * The card's associated runner.
+     */
+    @IsInt()
+    @IsOptional()
+    runner?: number;
+
+    /**
+     * Is the new card enabled (for fraud reasons)?
+     * Default: true
+     */
+    @IsBoolean()
+    enabled: boolean = true;
+
+    /**
+     * Creates a new RunnerCard entity from this.
+     */
+    public async toEntity(): Promise<RunnerCard> {
+        let newCard: RunnerCard = new RunnerCard();
+
+        newCard.enabled = this.enabled;
+        newCard.runner = await this.getRunner();
+
+        return newCard;
+    }
+
+    public async getRunner(): Promise<Runner> {
+        if (!this.runner) { return null; }
+        const runner = await getConnection().getRepository(Runner).findOne({ id: this.runner });
+        if (!runner) {
+            throw new RunnerNotFoundError();
+        }
+        return runner;
+    }
+}
--- a/src/models/actions/create/CreateRunnerGroup.ts
+++ b/src/models/actions/create/CreateRunnerGroup.ts
@@ -1,7 +1,7 @@
 import { IsInt, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { GroupContactNotFoundError, GroupContactWrongTypeError } from '../../errors/GroupContactErrors';
-import { GroupContact } from '../entities/GroupContact';
+import { GroupContactNotFoundError, GroupContactWrongTypeError } from '../../../errors/GroupContactErrors';
+import { GroupContact } from '../../entities/GroupContact';

 /**
 * This classed is used to create a new RunnerGroup entity from a json body (post request).
--- a/src/models/actions/create/CreateRunnerOrganisation.ts
+++ b/src/models/actions/create/CreateRunnerOrganisation.ts
@@ -1,8 +1,8 @@
 import { IsInt, IsOptional } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { AddressNotFoundError, AddressWrongTypeError } from '../../errors/AddressErrors';
-import { Address } from '../entities/Address';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
+import { AddressNotFoundError, AddressWrongTypeError } from '../../../errors/AddressErrors';
+import { Address } from '../../entities/Address';
+import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
 import { CreateRunnerGroup } from './CreateRunnerGroup';

 /**
@@ -36,7 +36,7 @@ export class CreateRunnerOrganisation extends CreateRunnerGroup {
    /**
     * Creates a new RunnerOrganisation entity from this.
     */
-    public async toRunnerOrganisation(): Promise<RunnerOrganisation> {
+    public async toEntity(): Promise<RunnerOrganisation> {
        let newRunnerOrganisation: RunnerOrganisation = new RunnerOrganisation();

        newRunnerOrganisation.name = this.name;
--- a/src/models/actions/create/CreateRunnerTeam.ts
+++ b/src/models/actions/create/CreateRunnerTeam.ts
@@ -1,9 +1,9 @@
 import { IsInt, IsNotEmpty } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../errors/RunnerOrganisationErrors';
-import { RunnerTeamNeedsParentError } from '../../errors/RunnerTeamErrors';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
-import { RunnerTeam } from '../entities/RunnerTeam';
+import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
+import { RunnerTeam } from '../../entities/RunnerTeam';
 import { CreateRunnerGroup } from './CreateRunnerGroup';

 /**
@@ -37,7 +37,7 @@ export class CreateRunnerTeam extends CreateRunnerGroup {
    /**
     * Creates a new RunnerTeam entity from this.
     */
-    public async toRunnerTeam(): Promise<RunnerTeam> {
+    public async toEntity(): Promise<RunnerTeam> {
        let newRunnerTeam: RunnerTeam = new RunnerTeam();

        newRunnerTeam.name = this.name;
--- a/src/models/actions/create/CreateScan.ts
+++ b/src/models/actions/create/CreateScan.ts
@@ -0,0 +1,59 @@
+import { IsBoolean, IsInt, IsOptional, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { Runner } from '../../entities/Runner';
+import { Scan } from '../../entities/Scan';
+
+/**
+ * This class is used to create a new Scan entity from a json body (post request).
+ */
+export abstract class CreateScan {
+    /**
+     * The scan's associated runner.
+     * This is important to link ran distances to runners.
+     */
+    @IsInt()
+    @IsPositive()
+    runner: number;
+
+    /**
+     * Is the scan valid (for fraud reasons).
+     * The determination of validity will work differently for every child class.
+     * Default: true
+     */
+    @IsBoolean()
+    @IsOptional()
+    valid?: boolean = true;
+
+    /**
+     * The scan's distance in meters.
+     * Can be set manually or derived from another object.
+     */
+    @IsInt()
+    @IsPositive()
+    public distance: number;
+
+    /**
+     * Creates a new Scan entity from this.
+     */
+    public async toEntity(): Promise<Scan> {
+        let newScan = new Scan();
+
+        newScan.distance = this.distance;
+        newScan.valid = this.valid;
+        newScan.runner = await this.getRunner();
+
+        return newScan;
+    }
+
+    /**
+     * 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;
+    }
+}
--- a/src/models/actions/create/CreateScanStation.ts
+++ b/src/models/actions/create/CreateScanStation.ts
@@ -0,0 +1,64 @@
+import * as argon2 from "argon2";
+import { IsBoolean, IsInt, IsOptional, IsPositive, IsString } from 'class-validator';
+import crypto from 'crypto';
+import { getConnection } from 'typeorm';
+import * as uuid from 'uuid';
+import { TrackNotFoundError } from '../../../errors/TrackErrors';
+import { ScanStation } from '../../entities/ScanStation';
+import { Track } from '../../entities/Track';
+
+/**
+ * This class is used to create a new StatsClient entity from a json body (post request).
+ */
+export class CreateScanStation {
+    /**
+     * The new station's description.
+     */
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    /**
+     * The station's associated track.
+     */
+    @IsInt()
+    @IsPositive()
+    track: number;
+
+    /**
+     * Is this station enabled?
+     */
+    @IsBoolean()
+    @IsOptional()
+    enabled?: boolean = true;
+
+    /**
+     * Converts this to a ScanStation entity.
+     */
+    public async toEntity(): Promise<ScanStation> {
+        let newStation: ScanStation = new ScanStation();
+
+        newStation.description = this.description;
+        newStation.enabled = this.enabled;
+        newStation.track = await this.getTrack();
+
+        let newUUID = uuid.v4().toUpperCase();
+        newStation.prefix = crypto.createHash("sha3-512").update(newUUID).digest('hex').substring(0, 7).toUpperCase();
+        newStation.key = await argon2.hash(newStation.prefix + "." + newUUID);
+        newStation.cleartextkey = newStation.prefix + "." + newUUID;
+
+        return newStation;
+    }
+
+    /**
+     * Get's a track by it's id provided via this.track.
+     * Used to link the new station to a track.
+     */
+    public async getTrack(): Promise<Track> {
+        const track = await getConnection().getRepository(Track).findOne({ id: this.track });
+        if (!track) {
+            throw new TrackNotFoundError();
+        }
+        return track;
+    }
+}
--- a/src/models/actions/create/CreateStatsClient.ts
+++ b/src/models/actions/create/CreateStatsClient.ts
@@ -2,7 +2,7 @@ import * as argon2 from "argon2";
 import { IsOptional, IsString } from 'class-validator';
 import crypto from 'crypto';
 import * as uuid from 'uuid';
-import { StatsClient } from '../entities/StatsClient';
+import { StatsClient } from '../../entities/StatsClient';

 /**
 * This classed is used to create a new StatsClient entity from a json body (post request).
@@ -18,7 +18,7 @@ export class CreateStatsClient {
    /**
     * Converts this to a StatsClient entity.
     */
-    public async toStatsClient(): Promise<StatsClient> {
+    public async toEntity(): Promise<StatsClient> {
        let newClient: StatsClient = new StatsClient();

        newClient.description = this.description;
--- a/src/models/actions/create/CreateTrack.ts
+++ b/src/models/actions/create/CreateTrack.ts
@@ -1,6 +1,6 @@
 import { IsInt, IsNotEmpty, IsOptional, IsPositive, IsString } from 'class-validator';
-import { TrackLapTimeCantBeNegativeError } from '../../errors/TrackErrors';
-import { Track } from '../entities/Track';
+import { TrackLapTimeCantBeNegativeError } from '../../../errors/TrackErrors';
+import { Track } from '../../entities/Track';

 /**
 * This classed is used to create a new Track entity from a json body (post request).
@@ -31,7 +31,7 @@ export class CreateTrack {
    /**
     * Creates a new Track entity from this.
     */
-    public toTrack(): Track {
+    public toEntity(): Track {
        let newTrack: Track = new Track();

        newTrack.name = this.name;
--- a/src/models/actions/create/CreateTrackScan.ts
+++ b/src/models/actions/create/CreateTrackScan.ts
@@ -0,0 +1,79 @@
+import { IsInt, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerCardNotFoundError } from '../../../errors/RunnerCardErrors';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { ScanStationNotFoundError } from '../../../errors/ScanStationErrors';
+import { RunnerCard } from '../../entities/RunnerCard';
+import { ScanStation } from '../../entities/ScanStation';
+import { TrackScan } from '../../entities/TrackScan';
+
+/**
+ * This classed is used to create a new Scan entity from a json body (post request).
+ */
+export class CreateTrackScan {
+    /**
+     * The runnerCard associated with the scan.
+     * This get's saved for documentation and management purposes.
+     */
+    @IsInt()
+    @IsPositive()
+    card: number;
+
+    /**
+     * The scanning station that created the scan.
+     * Mainly used for logging and traceing back scans (or errors)
+     */
+    @IsInt()
+    @IsPositive()
+    station: number;
+
+    /**
+     * Creates a new Track entity from this.
+     */
+    public async toEntity(): Promise<TrackScan> {
+        let newScan: TrackScan = new TrackScan();
+
+        newScan.station = await this.getStation();
+        newScan.card = await this.getCard();
+
+        newScan.track = newScan.station.track;
+        newScan.runner = newScan.card.runner;
+
+        if (!newScan.runner) {
+            throw new RunnerNotFoundError();
+        }
+
+        newScan.timestamp = Math.round(new Date().getTime() / 1000);
+        newScan.valid = await this.validateScan(newScan);
+
+        return newScan;
+    }
+
+    public async getCard(): Promise<RunnerCard> {
+        const track = await getConnection().getRepository(RunnerCard).findOne({ id: this.card }, { relations: ["runner"] });
+        if (!track) {
+            throw new RunnerCardNotFoundError();
+        }
+        return track;
+    }
+
+    public async getStation(): Promise<ScanStation> {
+        const station = await getConnection().getRepository(ScanStation).findOne({ id: this.station }, { relations: ["track"] });
+        if (!station) {
+            throw new ScanStationNotFoundError();
+        }
+        return station;
+    }
+
+    public async validateScan(scan: TrackScan): Promise<boolean> {
+        const scans = await getConnection().getRepository(TrackScan).find({ where: { runner: scan.runner, valid: true }, relations: ["track"] });
+        if (scans.length == 0) { return true; }
+
+        const newestScan = scans[scans.length - 1];
+        if ((scan.timestamp - newestScan.timestamp) > scan.track.minimumLapTime) {
+            return true;
+        }
+
+        return false;
+    }
+}
--- a/src/models/actions/create/CreateUser.ts
+++ b/src/models/actions/create/CreateUser.ts
@@ -1,124 +1,132 @@
-import * as argon2 from "argon2";
-import { IsBoolean, IsEmail, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
-import * as uuid from 'uuid';
-import { config } from '../../config';
-import { UsernameOrEmailNeededError } from '../../errors/UserErrors';
-import { UserGroupNotFoundError } from '../../errors/UserGroupErrors';
-import { User } from '../entities/User';
-import { UserGroup } from '../entities/UserGroup';
-
-/**
- * This classed is used to create a new User entity from a json body (post request).
- */
-export class CreateUser {
-    /**
-     * The new user's first name.
-     */
-    @IsString()
-    firstname: string;
-
-    /**
-     * The new user's middle name.
-     */
-    @IsString()
-    @IsOptional()
-    middlename?: string;
-
-    /**
-     * The new user's last name.
-     */
-    @IsString()
-    lastname: string;
-
-    /**
-     * The new user's username.
-     * You have to provide at least one of: {email, username}.
-     */
-    @IsOptional()
-    @IsString()
-    username?: string;
-
-    /**
-     * The new user's email address.
-     * You have to provide at least one of: {email, username}.
-     */
-    @IsEmail()
-    @IsString()
-    @IsOptional()
-    email?: string;
-
-    /**
-     * The new user's phone number.
-     * This will be validated against the configured country phone numer syntax (default: international).
-     */
-    @IsPhoneNumber(config.phone_validation_countrycode)
-    @IsOptional()
-    phone?: string;
-
-    /**
-     * The new user's password.
-     * This will of course not be saved in plaintext :)
-     */
-    @IsString()
-    password: string;
-
-    /**
-     * Will the new user be enabled from the start?
-     * Default: true
-     */
-    @IsBoolean()
-    @IsOptional()
-    enabled?: boolean = true;
-
-    /**
-     * The new user's groups' id(s).
-     * You can provide either one groupId or an array of groupIDs.
-     */
-    @IsOptional()
-    groups?: number[] | number
-
-    //TODO: ProfilePics
-
-    /**
-     * Converts this to a User entity.
-     */
-    public async toUser(): Promise<User> {
-        let newUser: User = new User();
-
-        if (this.email === undefined && this.username === undefined) {
-            throw new UsernameOrEmailNeededError();
-        }
-
-        newUser.email = this.email
-        newUser.username = this.username
-        newUser.firstname = this.firstname
-        newUser.middlename = this.middlename
-        newUser.lastname = this.lastname
-        newUser.uuid = uuid.v4()
-        newUser.phone = this.phone
-        newUser.password = await argon2.hash(this.password + newUser.uuid);
-        newUser.groups = await this.getGroups();
-        newUser.enabled = this.enabled;
-        //TODO: ProfilePics
-
-        return newUser;
-    }
-
-    /**
-     * Get's all groups for this user by their id's;
-     */
-    public async getGroups() {
-        if (!this.groups) { return null; }
-        let groups = new Array<UserGroup>();
-        if (!Array.isArray(this.groups)) {
-            this.groups = [this.groups]
-        }
-        for (let group of this.groups) {
-            let found = await getConnectionManager().get().getRepository(UserGroup).findOne({ id: group });
-            if (!found) { throw new UserGroupNotFoundError(); }
-            groups.push(found);
-        }
-        return groups;
-    }
+import * as argon2 from "argon2";
+import { IsBoolean, IsEmail, 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 { UserGroupNotFoundError } from '../../../errors/UserGroupErrors';
+import { User } from '../../entities/User';
+import { UserGroup } from '../../entities/UserGroup';
+
+/**
+ * This classed is used to create a new User entity from a json body (post request).
+ */
+export class CreateUser {
+    /**
+     * The new user's first name.
+     */
+    @IsString()
+    firstname: string;
+
+    /**
+     * The new user's middle name.
+     */
+    @IsString()
+    @IsOptional()
+    middlename?: string;
+
+    /**
+     * The new user's last name.
+     */
+    @IsString()
+    lastname: string;
+
+    /**
+     * The new user's username.
+     * You have to provide at least one of: {email, username}.
+     */
+    @IsOptional()
+    @IsString()
+    username?: string;
+
+    /**
+     * The new user's email address.
+     * You have to provide at least one of: {email, username}.
+     */
+    @IsEmail()
+    @IsString()
+    @IsOptional()
+    email?: string;
+
+    /**
+     * The new user's phone number.
+     * This will be validated against the configured country phone numer syntax (default: international).
+     */
+    @IsPhoneNumber(config.phone_validation_countrycode)
+    @IsOptional()
+    phone?: string;
+
+    /**
+     * The new user's password.
+     * This will of course not be saved in plaintext :)
+     */
+    @IsString()
+    password: string;
+
+    /**
+     * Will the new user be enabled from the start?
+     * Default: true
+     */
+    @IsBoolean()
+    @IsOptional()
+    enabled?: boolean = true;
+
+    /**
+     * The new user's groups' id(s).
+     * You can provide either one groupId or an array of groupIDs.
+     */
+    @IsOptional()
+    groups?: number[] | number
+
+    /**
+    * The user's profile pic (or rather a url pointing to it).
+    */
+    @IsString()
+    @IsUrl()
+    @IsOptional()
+    profilePic?: string;
+
+    /**
+     * Converts this to a User entity.
+     */
+    public async toEntity(): Promise<User> {
+        let newUser: User = new User();
+
+        if (this.email === undefined && this.username === undefined) {
+            throw new UsernameOrEmailNeededError();
+        }
+
+        newUser.email = this.email
+        newUser.username = this.username
+        newUser.firstname = this.firstname
+        newUser.middlename = this.middlename
+        newUser.lastname = this.lastname
+        newUser.uuid = uuid.v4()
+        newUser.phone = this.phone
+        newUser.password = await argon2.hash(this.password + newUser.uuid);
+        newUser.groups = await this.getGroups();
+        newUser.enabled = this.enabled;
+
+        if (!this.profilePic) { newUser.profilePic = `https://dev.lauf-fuer-kaya.de/lfk-logo.png`; }
+        else { newUser.profilePic = this.profilePic; }
+
+        return newUser;
+    }
+
+    /**
+     * Get's all groups for this user by their id's;
+     */
+    public async getGroups() {
+        if (!this.groups) { return null; }
+        let groups = new Array<UserGroup>();
+        if (!Array.isArray(this.groups)) {
+            this.groups = [this.groups]
+        }
+        for (let group of this.groups) {
+            let found = await getConnectionManager().get().getRepository(UserGroup).findOne({ id: group });
+            if (!found) { throw new UserGroupNotFoundError(); }
+            groups.push(found);
+        }
+        return groups;
+    }
 }
--- a/src/models/actions/create/CreateUserGroup.ts
+++ b/src/models/actions/create/CreateUserGroup.ts
@@ -1,5 +1,5 @@
 import { IsOptional, IsString } from 'class-validator';
-import { UserGroup } from '../entities/UserGroup';
+import { UserGroup } from '../../entities/UserGroup';

 /**
 * This classed is used to create a new UserGroup entity from a json body (post request).
@@ -22,7 +22,7 @@ export class CreateUserGroup {
    /**
     * Creates a new UserGroup entity from this.
     */
-    public async toUserGroup(): Promise<UserGroup> {
+    public async toEntity(): Promise<UserGroup> {
        let newUserGroup: UserGroup = new UserGroup();

        newUserGroup.name = this.name;
--- a/src/models/actions/update/UpdateDonor.ts
+++ b/src/models/actions/update/UpdateDonor.ts
@@ -1,7 +1,7 @@
 import { IsBoolean, IsInt, IsOptional } from 'class-validator';
-import { DonorReceiptAddressNeededError } from '../../errors/DonorErrors';
-import { Donor } from '../entities/Donor';
-import { CreateParticipant } from './CreateParticipant';
+import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
+import { Donor } from '../../entities/Donor';
+import { CreateParticipant } from '../create/CreateParticipant';

 /**
 * This class is used to update a Donor entity (via put request).
@@ -26,7 +26,7 @@ export class UpdateDonor extends CreateParticipant {
    /**
     * Updates a provided Donor entity based on this.
     */
-    public async updateDonor(donor: Donor): Promise<Donor> {
+    public async update(donor: Donor): Promise<Donor> {
        donor.firstname = this.firstname;
        donor.middlename = this.middlename;
        donor.lastname = this.lastname;
--- a/src/models/actions/update/UpdatePermission.ts
+++ b/src/models/actions/update/UpdatePermission.ts
@@ -1,11 +1,11 @@
 import { IsInt, IsNotEmpty, IsObject } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { PermissionNeedsPrincipalError } from '../../errors/PermissionErrors';
-import { PrincipalNotFoundError, PrincipalWrongTypeError } from '../../errors/PrincipalErrors';
-import { Permission } from '../entities/Permission';
-import { Principal } from '../entities/Principal';
-import { PermissionAction } from '../enums/PermissionAction';
-import { PermissionTarget } from '../enums/PermissionTargets';
+import { PermissionNeedsPrincipalError } from '../../../errors/PermissionErrors';
+import { PrincipalNotFoundError, PrincipalWrongTypeError } from '../../../errors/PrincipalErrors';
+import { Permission } from '../../entities/Permission';
+import { Principal } from '../../entities/Principal';
+import { PermissionAction } from '../../enums/PermissionAction';
+import { PermissionTarget } from '../../enums/PermissionTargets';

 /**
 * This class is used to update a Permission entity (via put request).
@@ -42,7 +42,7 @@ export class UpdatePermission {
    /**
     * Updates a provided Permission entity based on this.
     */
-    public async updatePermission(permission: Permission): Promise<Permission> {
+    public async update(permission: Permission): Promise<Permission> {
        permission.principal = await this.getPrincipal();
        permission.target = this.target;
        permission.action = this.action;
--- a/src/models/actions/update/UpdateRunner.ts
+++ b/src/models/actions/update/UpdateRunner.ts
@@ -1,11 +1,11 @@
 import { IsInt, IsObject } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerGroupNotFoundError } from '../../errors/RunnerGroupErrors';
-import { RunnerOrganisationWrongTypeError } from '../../errors/RunnerOrganisationErrors';
-import { RunnerTeamNeedsParentError } from '../../errors/RunnerTeamErrors';
-import { Runner } from '../entities/Runner';
-import { RunnerGroup } from '../entities/RunnerGroup';
-import { CreateParticipant } from './CreateParticipant';
+import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
+import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { Runner } from '../../entities/Runner';
+import { RunnerGroup } from '../../entities/RunnerGroup';
+import { CreateParticipant } from '../create/CreateParticipant';

 /**
 * This class is used to update a Runner entity (via put request).
@@ -29,7 +29,7 @@ export class UpdateRunner extends CreateParticipant {
    /**
     * Updates a provided Runner entity based on this.
     */
-    public async updateRunner(runner: Runner): Promise<Runner> {
+    public async update(runner: Runner): Promise<Runner> {
        runner.firstname = this.firstname;
        runner.middlename = this.middlename;
        runner.lastname = this.lastname;
--- a/src/models/actions/update/UpdateRunnerCard.ts
+++ b/src/models/actions/update/UpdateRunnerCard.ts
@@ -0,0 +1,51 @@
+import { IsBoolean, IsInt, IsOptional, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { Runner } from '../../entities/Runner';
+import { RunnerCard } from '../../entities/RunnerCard';
+
+/**
+ * This class is used to update a RunnerCard entity (via put request).
+ */
+export class UpdateRunnerCard {
+    /**
+     * The updated card'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()
+    @IsPositive()
+    id?: number;
+
+    /**
+     * The updated card's associated runner.
+     */
+    @IsInt()
+    @IsOptional()
+    runner?: number;
+
+    /**
+     * Is the updated card enabled (for fraud reasons)?
+     * Default: true
+     */
+    @IsBoolean()
+    enabled: boolean = true;
+
+    /**
+     * Creates a new RunnerCard entity from this.
+     */
+    public async update(card: RunnerCard): Promise<RunnerCard> {
+        card.enabled = this.enabled;
+        card.runner = await this.getRunner();
+
+        return card;
+    }
+
+    public async getRunner(): Promise<Runner> {
+        if (!this.runner) { return null; }
+        const runner = await getConnection().getRepository(Runner).findOne({ id: this.runner });
+        if (!runner) {
+            throw new RunnerNotFoundError();
+        }
+        return runner;
+    }
+}
--- a/src/models/actions/update/UpdateRunnerOrganisation.ts
+++ b/src/models/actions/update/UpdateRunnerOrganisation.ts
@@ -1,9 +1,9 @@
 import { IsInt, IsOptional } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { AddressNotFoundError } from '../../errors/AddressErrors';
-import { Address } from '../entities/Address';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
-import { CreateRunnerGroup } from './CreateRunnerGroup';
+import { AddressNotFoundError } from '../../../errors/AddressErrors';
+import { Address } from '../../entities/Address';
+import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
+import { CreateRunnerGroup } from '../create/CreateRunnerGroup';

 /**
 * This class is used to update a RunnerOrganisation entity (via put request).
@@ -41,7 +41,7 @@ export class UpdateRunnerOrganisation extends CreateRunnerGroup {
    /**
     * Updates a provided RunnerOrganisation entity based on this.
     */
-    public async updateRunnerOrganisation(organisation: RunnerOrganisation): Promise<RunnerOrganisation> {
+    public async update(organisation: RunnerOrganisation): Promise<RunnerOrganisation> {

        organisation.name = this.name;
        organisation.contact = await this.getContact();
--- a/src/models/actions/update/UpdateRunnerTeam.ts
+++ b/src/models/actions/update/UpdateRunnerTeam.ts
@@ -1,10 +1,10 @@
 import { IsInt, IsNotEmpty, IsObject } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../errors/RunnerOrganisationErrors';
-import { RunnerTeamNeedsParentError } from '../../errors/RunnerTeamErrors';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
-import { RunnerTeam } from '../entities/RunnerTeam';
-import { CreateRunnerGroup } from './CreateRunnerGroup';
+import { RunnerOrganisationNotFoundError, RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
+import { RunnerTeam } from '../../entities/RunnerTeam';
+import { CreateRunnerGroup } from '../create/CreateRunnerGroup';

 /**
 * This class is used to update a RunnerTeam entity (via put request).
@@ -45,7 +45,7 @@ export class UpdateRunnerTeam extends CreateRunnerGroup {
    /**
     * Updates a provided RunnerTeam entity based on this.
     */
-    public async updateRunnerTeam(team: RunnerTeam): Promise<RunnerTeam> {
+    public async update(team: RunnerTeam): Promise<RunnerTeam> {

        team.name = this.name;
        team.parentGroup = await this.getParent();
--- a/src/models/actions/update/UpdateScan.ts
+++ b/src/models/actions/update/UpdateScan.ts
@@ -0,0 +1,62 @@
+import { IsBoolean, IsInt, IsOptional, IsPositive } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { Runner } from '../../entities/Runner';
+import { Scan } from '../../entities/Scan';
+
+/**
+ * This class is used to update a Scan entity (via put request)
+ */
+export abstract class UpdateScan {
+    /**
+     * The updated scan'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 scan's associated runner.
+     * This is important to link ran distances to runners.
+     */
+    @IsInt()
+    @IsPositive()
+    runner: number;
+
+    /**
+     * Is the updated scan valid (for fraud reasons).
+     */
+    @IsBoolean()
+    @IsOptional()
+    valid?: boolean = true;
+
+    /**
+     * The updated scan's distance in meters.
+     */
+    @IsInt()
+    @IsPositive()
+    public distance: number;
+
+    /**
+     * Update a Scan entity based on this.
+     * @param scan The scan that shall be updated.
+     */
+    public async update(scan: Scan): Promise<Scan> {
+        scan.distance = this.distance;
+        scan.valid = this.valid;
+        scan.runner = await this.getRunner();
+
+        return scan;
+    }
+
+    /**
+     * 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;
+    }
+}
--- a/src/models/actions/update/UpdateScanStation.ts
+++ b/src/models/actions/update/UpdateScanStation.ts
@@ -0,0 +1,39 @@
+import { IsBoolean, IsInt, IsOptional, IsString } from 'class-validator';
+import { ScanStation } from '../../entities/ScanStation';
+
+/**
+ * This class is used to update a ScanStation entity (via put request)
+ */
+export class UpdateScanStation {
+    /**
+     * The updated station'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 station's description.
+     */
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    /**
+     * Is this station enabled?
+     */
+    @IsBoolean()
+    @IsOptional()
+    enabled?: boolean = true;
+
+    /**
+     * Update a ScanStation entity based on this.
+     * @param station The station that shall be updated.
+     */
+    public async update(station: ScanStation): Promise<ScanStation> {
+        station.description = this.description;
+        station.enabled = this.enabled;
+
+        return station;
+    }
+}
--- a/src/models/actions/update/UpdateTrack.ts
+++ b/src/models/actions/update/UpdateTrack.ts
@@ -1,6 +1,6 @@
 import { IsInt, IsNotEmpty, IsOptional, IsPositive, IsString } from 'class-validator';
-import { TrackLapTimeCantBeNegativeError } from '../../errors/TrackErrors';
-import { Track } from '../entities/Track';
+import { TrackLapTimeCantBeNegativeError } from '../../../errors/TrackErrors';
+import { Track } from '../../entities/Track';

 /**
 * This class is used to update a Track entity (via put request).
@@ -37,7 +37,7 @@ export class UpdateTrack {
     * Update a Track entity based on this.
     * @param track The track that shall be updated.
     */
-    public updateTrack(track: Track): Track {
+    public async update(track: Track): Promise<Track> {
        track.name = this.name;
        track.distance = this.distance;
        track.minimumLapTime = this.minimumLapTime;
--- a/src/models/actions/update/UpdateTrackScan.ts
+++ b/src/models/actions/update/UpdateTrackScan.ts
@@ -0,0 +1,81 @@
+import { IsBoolean, IsInt, IsOptional } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerNotFoundError } from '../../../errors/RunnerErrors';
+import { ScanStationNotFoundError } from '../../../errors/ScanStationErrors';
+import { Runner } from '../../entities/Runner';
+import { ScanStation } from '../../entities/ScanStation';
+import { TrackScan } from '../../entities/TrackScan';
+
+/**
+ * This class is used to update a TrackScan entity (via put request)
+ */
+export abstract class UpdateTrackScan {
+    /**
+     * The updated scan'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 scan's associated runner.
+     * This is important to link ran distances to runners.
+     */
+    @IsInt()
+    @IsOptional()
+    runner?: number;
+
+    /**
+     * Is the updated scan valid (for fraud reasons).
+     */
+    @IsBoolean()
+    @IsOptional()
+    valid?: boolean = true;
+
+    /**
+     * The updated scan's associated station.
+     * This is important to link ran distances to runners.
+     */
+    @IsInt()
+    @IsOptional()
+    public station?: number;
+
+    /**
+     * Update a TrackScan entity based on this.
+     * @param scan The scan that shall be updated.
+     */
+    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.track = scan.station.track;
+
+        return scan;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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 });
+        if (!station) {
+            throw new ScanStationNotFoundError();
+        }
+        return station;
+    }
+}
--- a/src/models/actions/update/UpdateUser.ts
+++ b/src/models/actions/update/UpdateUser.ts
@@ -1,11 +1,11 @@
 import * as argon2 from "argon2";
-import { IsBoolean, IsEmail, IsInt, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { IsBoolean, IsEmail, IsInt, IsOptional, IsPhoneNumber, IsString, IsUrl } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { config } from '../../config';
-import { UsernameOrEmailNeededError } from '../../errors/AuthError';
-import { UserGroupNotFoundError } from '../../errors/UserGroupErrors';
-import { User } from '../entities/User';
-import { UserGroup } from '../entities/UserGroup';
+import { config } from '../../../config';
+import { UsernameOrEmailNeededError } from '../../../errors/AuthError';
+import { UserGroupNotFoundError } from '../../../errors/UserGroupErrors';
+import { User } from '../../entities/User';
+import { UserGroup } from '../../entities/UserGroup';

 /**
 * This class is used to update a User entity (via put request).
@@ -87,9 +87,18 @@ export class UpdateUser {
    groups?: UserGroup[]

    /**
-     * Updates a provided User entity based on this.
+    * The user's profile pic (or rather a url pointing to it).
+    */
+    @IsString()
+    @IsUrl()
+    @IsOptional()
+    profilePic?: string;
+
+    /**
+     * Updates a user entity based on this.
+     * @param user The user that shall be updated.
     */
-    public async updateUser(user: User): Promise<User> {
+    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)) {
@@ -106,7 +115,9 @@ export class UpdateUser {
        user.lastname = this.lastname
        user.phone = this.phone;
        user.groups = await this.getGroups();
-        //TODO: ProfilePics
+
+        if (!this.profilePic) { user.profilePic = `https://dev.lauf-fuer-kaya.de/lfk-logo.png`; }
+        else { user.profilePic = this.profilePic; }

        return user;
    }
--- a/src/models/actions/update/UpdateUserGroup.ts
+++ b/src/models/actions/update/UpdateUserGroup.ts
@@ -0,0 +1,39 @@
+import { IsInt, IsOptional, IsString } from 'class-validator';
+import { UserGroup } from '../../entities/UserGroup';
+
+/**
+ * This class is used to update a UserGroup entity (via put request).
+ */
+export class UpdateUserGroup {
+
+    /**
+     * The updated group'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 group's name.
+     */
+    @IsString()
+    name: string;
+
+    /**
+     * The updated groups's description.
+     */
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    /**
+     * Updates a group entity based on this.
+     * @param group The group that shall be updated.
+     */
+    public async update(group: UserGroup): Promise<UserGroup> {
+        group.name = this.name;
+        group.description = this.description;
+
+        return group;
+    }
+}
--- a/src/models/entities/Address.ts
+++ b/src/models/entities/Address.ts
@@ -80,4 +80,11 @@ export class Address {
   */
  @OneToMany(() => IAddressUser, addressUser => addressUser.address, { nullable: true })
  addressUsers: IAddressUser[];
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/entities/DistanceDonation.ts
+++ b/src/models/entities/DistanceDonation.ts
@@ -39,4 +39,11 @@ export class DistanceDonation extends Donation {
    }
    return calculatedAmount;
  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/entities/Donation.ts
+++ b/src/models/entities/Donation.ts
@@ -32,4 +32,11 @@ export abstract class Donation {
   * The exact implementation may differ for each type of donation.
   */
  abstract amount: number;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/entities/Donor.ts
+++ b/src/models/entities/Donor.ts
@@ -1,5 +1,6 @@
 import { IsBoolean } from "class-validator";
 import { ChildEntity, Column, OneToMany } from "typeorm";
+import { ResponseDonor } from '../responses/ResponseDonor';
 import { Donation } from './Donation';
 import { Participant } from "./Participant";

@@ -22,4 +23,11 @@ export class Donor extends Participant {
 */
  @OneToMany(() => Donation, donation => donation.donor, { nullable: true })
  donations: Donation[];
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseDonor {
+    return new ResponseDonor(this);
+  }
 }
--- a/src/models/entities/FixedDonation.ts
+++ b/src/models/entities/FixedDonation.ts
@@ -16,4 +16,11 @@ export class FixedDonation extends Donation {
  @IsInt()
  @IsPositive()
  amount: number;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/entities/GroupContact.ts
+++ b/src/models/entities/GroupContact.ts
@@ -81,4 +81,11 @@ export class GroupContact implements IAddressUser {
    */
  @OneToMany(() => RunnerGroup, group => group.contact, { nullable: true })
  groups: RunnerGroup[];
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/entities/IAddressUser.ts
+++ b/src/models/entities/IAddressUser.ts
@@ -12,4 +12,9 @@ export abstract class IAddressUser {

    @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
    address?: Address
+
+    /**
+   * Turns this entity into it's response class.
+   */
+    public abstract toResponse();
 }
--- a/src/models/entities/Participant.ts
+++ b/src/models/entities/Participant.ts
@@ -9,6 +9,7 @@ import {
 } from "class-validator";
 import { Column, Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
 import { config } from '../../config';
+import { ResponseParticipant } from '../responses/ResponseParticipant';
 import { Address } from "./Address";
 import { IAddressUser } from './IAddressUser';

@@ -74,4 +75,9 @@ export abstract class Participant implements IAddressUser {
  @IsOptional()
  @IsEmail()
  email?: string;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public abstract toResponse(): ResponseParticipant;
 }
--- a/src/models/entities/Permission.ts
+++ b/src/models/entities/Permission.ts
@@ -6,6 +6,7 @@ import {
 import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from "typeorm";
 import { PermissionAction } from '../enums/PermissionAction';
 import { PermissionTarget } from '../enums/PermissionTargets';
+import { ResponsePermission } from '../responses/ResponsePermission';
 import { Principal } from './Principal';
 /**
 * Defines the Permission entity.
@@ -51,4 +52,11 @@ export class Permission {
  public toString(): string {
    return this.target + ":" + this.action;
  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponsePermission {
+    return new ResponsePermission(this);
+  }
 }
--- a/src/models/entities/Runner.ts
+++ b/src/models/entities/Runner.ts
@@ -1,5 +1,6 @@
 import { IsInt, IsNotEmpty } from "class-validator";
 import { ChildEntity, ManyToOne, OneToMany } from "typeorm";
+import { ResponseRunner } from '../responses/ResponseRunner';
 import { DistanceDonation } from "./DistanceDonation";
 import { Participant } from "./Participant";
 import { RunnerCard } from "./RunnerCard";
@@ -47,7 +48,7 @@ export class Runner extends Participant {
   * This is implemented here to avoid duplicate code in other files.
   */
  public get validScans(): Scan[] {
-    return this.scans.filter(scan => { scan.valid === true });
+    return this.scans.filter(scan => scan.valid == true);
  }

  /**
@@ -66,4 +67,11 @@ export class Runner extends Participant {
  public get distanceDonationAmount(): number {
    return this.distanceDonations.reduce((sum, current) => sum + current.amountPerDistance, 0) * this.distance;
  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseRunner {
+    return new ResponseRunner(this);
+  }
 }
--- a/src/models/entities/RunnerCard.ts
+++ b/src/models/entities/RunnerCard.ts
@@ -1,12 +1,13 @@
 import {
  IsBoolean,
-  IsEAN,
+
  IsInt,
-  IsNotEmpty,
-  IsOptional,
-  IsString
+
+  IsOptional
 } from "class-validator";
 import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { RunnerCardIdOutOfRangeError } from '../../errors/RunnerCardErrors';
+import { ResponseRunnerCard } from '../responses/ResponseRunnerCard';
 import { Runner } from "./Runner";
 import { TrackScan } from "./TrackScan";

@@ -32,17 +33,6 @@ export class RunnerCard {
  @ManyToOne(() => Runner, runner => runner.cards, { nullable: true })
  runner: Runner;

-  /**
-   * The card's code.
-   * This has to be able to being converted to something barcode compatible.
-   * Will get automaticlly generated (not implemented yet).
-   */
-  @Column()
-  @IsEAN()
-  @IsString()
-  @IsNotEmpty()
-  code: string;
-
  /**
   * Is the card enabled (for fraud reasons)?
   * Default: true
@@ -57,4 +47,38 @@ export class RunnerCard {
   */
  @OneToMany(() => TrackScan, scan => scan.track, { nullable: true })
  scans: TrackScan[];
+
+  /**
+   * Generates a ean-13 compliant string for barcode generation.
+   */
+  public get code(): string {
+    const multiply = [1, 3];
+    let total = 0;
+    this.paddedId.split('').forEach((letter, index) => {
+      total += parseInt(letter, 10) * multiply[index % 2];
+    });
+    const checkSum = (Math.ceil(total / 10) * 10) - total;
+    return this.paddedId + checkSum.toString();
+  }
+
+  /**
+   * Returns this card's id as a string padded to the length of 12 characters with leading zeros.
+   */
+  private get paddedId(): string {
+    let id: string = this.id.toString();
+
+    if (id.length > 12) {
+      throw new RunnerCardIdOutOfRangeError();
+    }
+    while (id.length < 12) { id = '0' + id; }
+
+    return id;
+  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new ResponseRunnerCard(this);
+  }
 }
--- a/src/models/entities/RunnerGroup.ts
+++ b/src/models/entities/RunnerGroup.ts
@@ -5,6 +5,7 @@ import {
  IsString
 } from "class-validator";
 import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
+import { ResponseRunnerGroup } from '../responses/ResponseRunnerGroup';
 import { GroupContact } from "./GroupContact";
 import { Runner } from "./Runner";

@@ -60,4 +61,9 @@ export abstract class RunnerGroup {
  public get distanceDonationAmount(): number {
    return this.runners.reduce((sum, current) => sum + current.distanceDonationAmount, 0);
  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public abstract toResponse(): ResponseRunnerGroup;
 }
--- a/src/models/entities/RunnerOrganisation.ts
+++ b/src/models/entities/RunnerOrganisation.ts
@@ -1,5 +1,6 @@
 import { IsInt, IsOptional } from "class-validator";
 import { ChildEntity, ManyToOne, OneToMany } from "typeorm";
+import { ResponseRunnerOrganisation } from '../responses/ResponseRunnerOrganisation';
 import { Address } from './Address';
 import { IAddressUser } from './IAddressUser';
 import { Runner } from './Runner';
@@ -54,4 +55,11 @@ export class RunnerOrganisation extends RunnerGroup implements IAddressUser {
  public get distanceDonationAmount(): number {
    return this.allRunners.reduce((sum, current) => sum + current.distanceDonationAmount, 0);
  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseRunnerOrganisation {
+    return new ResponseRunnerOrganisation(this);
+  }
 }
--- a/src/models/entities/RunnerTeam.ts
+++ b/src/models/entities/RunnerTeam.ts
@@ -1,5 +1,6 @@
 import { IsNotEmpty } from "class-validator";
 import { ChildEntity, ManyToOne } from "typeorm";
+import { ResponseRunnerTeam } from '../responses/ResponseRunnerTeam';
 import { RunnerGroup } from "./RunnerGroup";
 import { RunnerOrganisation } from "./RunnerOrganisation";

@@ -17,4 +18,11 @@ export class RunnerTeam extends RunnerGroup {
  @IsNotEmpty()
  @ManyToOne(() => RunnerOrganisation, org => org.teams, { nullable: true })
  parentGroup?: RunnerOrganisation;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseRunnerTeam {
+    return new ResponseRunnerTeam(this);
+  }
 }
--- a/src/models/entities/Scan.ts
+++ b/src/models/entities/Scan.ts
@@ -6,6 +6,7 @@ import {
  IsPositive
 } from "class-validator";
 import { Column, Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
+import { ResponseScan } from '../responses/ResponseScan';
 import { Runner } from "./Runner";

 /**
@@ -14,7 +15,7 @@ import { Runner } from "./Runner";
 */
@Entity()
@TableInheritance({ column: { name: "type", type: "varchar" } })
-export abstract class Scan {
+export class Scan {
  /**
   * Autogenerated unique id (primary key).
   */
@@ -30,14 +31,6 @@ export abstract class Scan {
  @ManyToOne(() => Runner, runner => runner.scans, { nullable: false })
  runner: Runner;

-  /**
-   * The scan's distance in meters.
-   * Can be set manually or derived from another object.
-   */
-  @IsInt()
-  @IsPositive()
-  abstract distance: number;
-
  /**
   * Is the scan valid (for fraud reasons).
   * The determination of validity will work differently for every child class.
@@ -46,4 +39,37 @@ export abstract class Scan {
  @Column()
  @IsBoolean()
  valid: boolean = true;
+
+  /**
+   * The scan's distance in meters.
+   * This is the "real" value used by "normal" scans..
+   */
+  @Column({ nullable: true })
+  @IsInt()
+  private _distance?: number;
+
+  /**
+   * The scan's distance in meters.
+   * Can be set manually or derived from another object.
+   */
+  @IsInt()
+  @IsPositive()
+  public get distance(): number {
+    return this._distance;
+  }
+
+  /**
+   * The scan's distance in meters.
+   * Can be set manually or derived from another object.
+   */
+  public set distance(value: number) {
+    this._distance = value;
+  }
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseScan {
+    return new ResponseScan(this);
+  }
 }
--- a/src/models/entities/ScanStation.ts
+++ b/src/models/entities/ScanStation.ts
@@ -6,6 +6,7 @@ import {
  IsString
 } from "class-validator";
 import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { ResponseScanStation } from '../responses/ResponseScanStation';
 import { Track } from "./Track";
 import { TrackScan } from "./TrackScan";

@@ -39,6 +40,14 @@ export class ScanStation {
  @ManyToOne(() => Track, track => track.stations, { nullable: false })
  track: Track;

+  /**
+   * The client's api key prefix.
+   * This is used identitfy a client by it's api key.
+   */
+  @Column({ unique: true })
+  @IsString()
+  prefix: string;
+
  /**
   * The station's api key.
   * This is used to authorize a station against the api (not implemented yet).
@@ -49,16 +58,30 @@ export class ScanStation {
  key: string;

  /**
-   * Is the station enabled (for fraud and setup reasons)?
-   * Default: true
+   * The client's api key in plain text.
+   * This will only be used to display the full key on creation and updates.
   */
-  @Column()
-  @IsBoolean()
-  enabled: boolean = true;
+  @IsString()
+  @IsOptional()
+  cleartextkey?: string;

  /**
   * Used to link track scans to a scan station.
   */
  @OneToMany(() => TrackScan, scan => scan.track, { nullable: true })
  scans: TrackScan[];
+
+  /**
+  * Is this station enabled?
+  */
+  @Column({ nullable: true })
+  @IsBoolean()
+  enabled?: boolean = true;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseScanStation {
+    return new ResponseScanStation(this);
+  }
 }
--- a/src/models/entities/StatsClient.ts
+++ b/src/models/entities/StatsClient.ts
@@ -1,5 +1,6 @@
 import { IsInt, IsOptional, IsString } from "class-validator";
 import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { ResponseStatsClient } from '../responses/ResponseStatsClient';
 /**
 * Defines the StatsClient entity.
 * StatsClients can be used to access the protected parts of the stats api (top runners, donators and so on).
@@ -45,4 +46,11 @@ export class StatsClient {
    @IsString()
    @IsOptional()
    cleartextkey?: string;
+
+    /**
+   * Turns this entity into it's response class.
+   */
+    public toResponse(): ResponseStatsClient {
+        return new ResponseStatsClient(this);
+    }
 }
--- a/src/models/entities/Track.ts
+++ b/src/models/entities/Track.ts
@@ -6,6 +6,7 @@ import {
  IsString
 } from "class-validator";
 import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { ResponseTrack } from '../responses/ResponseTrack';
 import { ScanStation } from "./ScanStation";
 import { TrackScan } from "./TrackScan";

@@ -61,4 +62,11 @@ export class Track {
   */
  @OneToMany(() => TrackScan, scan => scan.track, { nullable: true })
  scans: TrackScan[];
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseTrack {
+    return new ResponseTrack(this);
+  }
 }
--- a/src/models/entities/TrackScan.ts
+++ b/src/models/entities/TrackScan.ts
@@ -1,11 +1,11 @@
 import {
-  IsDateString,
  IsInt,
  IsNotEmpty,

  IsPositive
 } from "class-validator";
 import { ChildEntity, Column, ManyToOne } from "typeorm";
+import { ResponseTrackScan } from '../responses/ResponseTrackScan';
 import { RunnerCard } from "./RunnerCard";
 import { Scan } from "./Scan";
 import { ScanStation } from "./ScanStation";
@@ -56,7 +56,13 @@ export class TrackScan extends Scan {
   * Will be used to implement fraud detection.
   */
  @Column()
-  @IsDateString()
-  @IsNotEmpty()
-  timestamp: string;
+  @IsInt()
+  timestamp: number;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponseTrackScan {
+    return new ResponseTrackScan(this);
+  }
 }
--- a/src/models/entities/User.ts
+++ b/src/models/entities/User.ts
@@ -1,4 +1,4 @@
-import { IsBoolean, IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString, IsUUID } from "class-validator";
+import { IsBoolean, IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString, IsUrl, IsUUID } from "class-validator";
 import { ChildEntity, Column, JoinTable, ManyToMany, OneToMany } from "typeorm";
 import { config } from '../../config';
 import { ResponsePrincipal } from '../responses/ResponsePrincipal';
@@ -106,10 +106,10 @@ export class User extends Principal {
  * The user's profile picture.
  * We haven't decided yet if this will be a bas64 encoded image or just a link to the profile picture.
  */
-  @Column({ nullable: true, unique: false })
+  @Column({ nullable: false, unique: false })
  @IsString()
-  @IsOptional()
-  profilePic?: string;
+  @IsUrl()
+  profilePic: string;

  /**
  * The last time the user requested a password reset.
@@ -128,6 +128,26 @@ export class User extends Principal {
  @OneToMany(() => UserAction, action => action.user, { nullable: true })
  actions: UserAction[]

+  /**
+   * Resolves all permissions granted to this user through groups or directly to the string enum format.
+   */
+  public get allPermissions(): string[] {
+    let returnPermissions: string[] = new Array<string>();
+
+    if (!this.permissions) { return returnPermissions; }
+    for (let permission of this.permissions) {
+      returnPermissions.push(permission.toString());
+    }
+
+    if (!this.groups) { return returnPermissions; }
+    for (let group of this.groups) {
+      for (let permission of group.permissions) {
+        returnPermissions.push(permission.toString());
+      }
+    }
+    return Array.from(new Set(returnPermissions));
+  }
+
  /**
   * Turns this entity into it's response class.
   */
--- a/src/models/entities/UserAction.ts
+++ b/src/models/entities/UserAction.ts
@@ -52,4 +52,11 @@ export class UserAction {
  @IsOptional()
  @IsString()
  changed: string;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse() {
+    return new Error("NotImplemented");
+  }
 }
--- a/src/models/enums/PermissionTargets.ts
+++ b/src/models/enums/PermissionTargets.ts
@@ -10,5 +10,8 @@ export enum PermissionTarget {
    USERGROUP = 'USERGROUP',
    PERMISSION = 'PERMISSION',
    STATSCLIENT = 'STATSCLIENT',
-    DONOR = 'DONOR'
+    DONOR = 'DONOR',
+    SCAN = 'SCAN',
+    STATION = 'STATION',
+    CARD = 'CARD'
 }
--- a/src/models/responses/ResponseAuth.ts
+++ b/src/models/responses/ResponseAuth.ts
@@ -3,7 +3,7 @@ import { IsInt, IsString } from 'class-validator';
 /**
 * Defines the repsonse auth.
 */
-export class Auth {
+export class ResponseAuth {
  /**
  * The access_token - JWT shortterm access token.
  */
--- a/src/models/responses/ResponseRunner.ts
+++ b/src/models/responses/ResponseRunner.ts
@@ -29,7 +29,8 @@ export class ResponseRunner extends ResponseParticipant {
     */
    public constructor(runner: Runner) {
        super(runner);
-        this.distance = runner.scans.filter(scan => { scan.valid === true }).reduce((sum, current) => sum + current.distance, 0);
+        if (!runner.scans) { this.distance = 0 }
+        else { this.distance = runner.validScans.reduce((sum, current) => sum + current.distance, 0); }
        this.group = runner.group;
    }
 }
--- a/src/models/responses/ResponseRunnerCard.ts
+++ b/src/models/responses/ResponseRunnerCard.ts
@@ -0,0 +1,53 @@
+import { IsBoolean, IsEAN, IsInt, IsNotEmpty, IsObject, IsString } from "class-validator";
+import { RunnerCard } from '../entities/RunnerCard';
+import { ResponseRunner } from './ResponseRunner';
+
+/**
+ * Defines the runner card response.
+*/
+export class ResponseRunnerCard {
+    /**
+     * The card's id.
+     */
+    @IsInt()
+    id: number;;
+
+    /**
+     * The card's associated runner.
+     * This is important to link scans to runners.
+     */
+    @IsObject()
+    runner: ResponseRunner | null;
+
+    /**
+     * The card's code.
+     */
+    @IsEAN()
+    @IsString()
+    @IsNotEmpty()
+    code: string;
+
+    /**
+     * Is the enabled valid (for fraud reasons).
+     * The determination of validity will work differently for every child class.
+     */
+    @IsBoolean()
+    enabled: boolean = true;
+
+    /**
+     * Creates a ResponseRunnerCard object from a runner card.
+     * @param card The card the response shall be build for.
+     */
+    public constructor(card: RunnerCard) {
+        this.id = card.id;
+        if (!card.runner) { this.runner = null }
+        else { this.runner = card.runner.toResponse(); }
+        try {
+            this.code = card.code;
+        } catch (error) {
+            this.code = "0000000000000"
+        }
+
+        this.enabled = card.enabled;
+    }
+}
--- a/src/models/responses/ResponseScan.ts
+++ b/src/models/responses/ResponseScan.ts
@@ -0,0 +1,46 @@
+import { IsBoolean, IsInt, IsNotEmpty, IsPositive } from "class-validator";
+import { Scan } from '../entities/Scan';
+import { ResponseRunner } from './ResponseRunner';
+
+/**
+ * Defines the scan response.
+*/
+export class ResponseScan {
+    /**
+     * The scans's id.
+     */
+    @IsInt()
+    id: number;;
+
+    /**
+     * The scan's associated runner.
+     * This is important to link ran distances to runners.
+     */
+    @IsNotEmpty()
+    runner: ResponseRunner;
+
+    /**
+     * Is the scan valid (for fraud reasons).
+     * The determination of validity will work differently for every child class.
+     */
+    @IsBoolean()
+    valid: boolean = true;
+
+    /**
+     * The scans's length/distance in meters.
+     */
+    @IsInt()
+    @IsPositive()
+    distance: number;
+
+    /**
+     * Creates a ResponseScan object from a scan.
+     * @param scan The scan the response shall be build for.
+     */
+    public constructor(scan: Scan) {
+        this.id = scan.id;
+        this.runner = scan.runner.toResponse();
+        this.distance = scan.distance;
+        this.valid = scan.valid;
+    }
+}
--- a/src/models/responses/ResponseScanStation.ts
+++ b/src/models/responses/ResponseScanStation.ts
@@ -0,0 +1,70 @@
+import {
+
+    IsBoolean,
+    IsInt,
+
+    IsNotEmpty,
+
+    IsObject,
+
+    IsOptional,
+    IsString
+} from "class-validator";
+import { ScanStation } from '../entities/ScanStation';
+import { ResponseTrack } from './ResponseTrack';
+
+/**
+ * Defines the statsClient response.
+*/
+export class ResponseScanStation {
+    /**
+     * The client's id.
+     */
+    @IsInt()
+    id: number;
+
+    /**
+     * The client's description.
+     */
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    /**
+     * The client's api key.
+     * Only visible on creation or regeneration.
+     */
+    @IsString()
+    @IsOptional()
+    key: string;
+
+    /**
+     * The client's api key prefix.
+     */
+    @IsString()
+    @IsNotEmpty()
+    prefix: string;
+
+    @IsObject()
+    @IsNotEmpty()
+    track: ResponseTrack;
+
+    /**
+     * Is this station enabled?
+     */
+    @IsBoolean()
+    enabled?: boolean = true;
+
+    /**
+     * Creates a ResponseStatsClient object from a statsClient.
+     * @param client The statsClient the response shall be build for.
+     */
+    public constructor(station: ScanStation) {
+        this.id = station.id;
+        this.description = station.description;
+        this.prefix = station.prefix;
+        this.key = "Only visible on creation.";
+        this.track = station.track;
+        this.enabled = station.enabled;
+    }
+}
--- a/src/models/responses/ResponseTrackScan.ts
+++ b/src/models/responses/ResponseTrackScan.ts
@@ -0,0 +1,49 @@
+import { IsDateString, IsNotEmpty } from "class-validator";
+import { TrackScan } from '../entities/TrackScan';
+import { ResponseRunnerCard } from './ResponseRunnerCard';
+import { ResponseScan } from './ResponseScan';
+import { ResponseScanStation } from './ResponseScanStation';
+import { ResponseTrack } from './ResponseTrack';
+
+/**
+ * Defines the trackScan response.
+*/
+export class ResponseTrackScan extends ResponseScan {
+    /**
+   * The scan's associated track.
+   */
+    @IsNotEmpty()
+    track: ResponseTrack;
+
+    /**
+     * The runnerCard associated with the scan.
+     */
+    @IsNotEmpty()
+    card: ResponseRunnerCard;
+
+    /**
+     * The scanning station that created the scan.
+     */
+    @IsNotEmpty()
+    station: ResponseScanStation;
+
+    /**
+     * The scan's creation timestamp.
+     */
+    @IsDateString()
+    @IsNotEmpty()
+    timestamp: number;
+
+    /**
+     * Creates a ResponseTrackScan object from a scan.
+     * @param scan The trackSscan the response shall be build for.
+     */
+    public constructor(scan: TrackScan) {
+        super(scan);
+        this.track = new ResponseTrack(scan.track);
+        this.card = scan.card.toResponse();
+        this.station = scan.station.toResponse();
+        this.timestamp = scan.timestamp;
+        this.distance = scan.distance;
+    }
+}
--- a/src/models/responses/ResponseUser.ts
+++ b/src/models/responses/ResponseUser.ts
@@ -5,7 +5,6 @@ import {
    IsOptional,
    IsString
 } from "class-validator";
-import { Permission } from '../entities/Permission';
 import { User } from '../entities/User';
 import { UserGroup } from '../entities/UserGroup';
 import { ResponsePrincipal } from './ResponsePrincipal';
@@ -57,11 +56,10 @@ export class ResponseUser extends ResponsePrincipal {
    enabled: boolean = true;

    /**
-    * The user's profile pic.
+    * The user's profile pic (or rather a url pointing to it).
    */
    @IsString()
-    @IsOptional()
-    profilePic?: string;
+    profilePic: string;

    /**
     * The groups that the user is a part of.
@@ -75,7 +73,7 @@ export class ResponseUser extends ResponsePrincipal {
     */
    @IsArray()
    @IsOptional()
-    permissions: Permission[];
+    permissions: string[];

    /**
     * Creates a ResponseUser object from a user.
@@ -92,6 +90,7 @@ export class ResponseUser extends ResponsePrincipal {
        this.enabled = user.enabled;
        this.profilePic = user.profilePic;
        this.groups = user.groups;
-        this.permissions = user.permissions;
+        this.permissions = user.allPermissions;
+        this.groups.forEach(function (g) { delete g.permissions });
    }
 }
--- a/src/seeds/SeedUsers.ts
+++ b/src/seeds/SeedUsers.ts
@@ -1,8 +1,8 @@
 import { Connection } from 'typeorm';
 import { Factory, Seeder } from 'typeorm-seeding';
-import { CreatePermission } from '../models/actions/CreatePermission';
-import { CreateUser } from '../models/actions/CreateUser';
-import { CreateUserGroup } from '../models/actions/CreateUserGroup';
+import { CreatePermission } from '../models/actions/create/CreatePermission';
+import { CreateUser } from '../models/actions/create/CreateUser';
+import { CreateUserGroup } from '../models/actions/create/CreateUserGroup';
 import { Permission } from '../models/entities/Permission';
 import { User } from '../models/entities/User';
 import { UserGroup } from '../models/entities/UserGroup';
@@ -24,7 +24,7 @@ export default class SeedUsers implements Seeder {
        let adminGroup = new CreateUserGroup();
        adminGroup.name = "ADMINS";
        adminGroup.description = "Have all possible permissions";
-        return await connection.getRepository(UserGroup).save(await adminGroup.toUserGroup());
+        return await connection.getRepository(UserGroup).save(await adminGroup.toEntity());
    }

    public async createUser(connection: Connection, group: number) {
@@ -34,7 +34,7 @@ export default class SeedUsers implements Seeder {
        initialUser.username = "demo";
        initialUser.password = "demo";
        initialUser.groups = group;
-        return await connection.getRepository(User).save(await initialUser.toUser());
+        return await connection.getRepository(User).save(await initialUser.toEntity());
    }

    public async createPermissions(connection: Connection, principal: number) {
@@ -45,7 +45,7 @@ export default class SeedUsers implements Seeder {
                permission.target = <PermissionTarget>target;
                permission.action = <PermissionAction>action;
                permission.principal = principal;
-                await repo.save(await permission.toPermission());
+                await repo.save(await permission.toEntity());
            }
        }
    }
--- a/src/tests/cards/cards_add.spec.ts
+++ b/src/tests/cards/cards_add.spec.ts
@@ -0,0 +1,144 @@
+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/cards illegally', () => {
+	it('non-existant runner input should return 404', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"runner": 999999999999999999999999
+		}, axios_config);
+		expect(res.status).toEqual(404);
+		expect(res.headers['content-type']).toContain("application/json")
+	});
+});
+// ---------------
+describe('POST /api/cards successfully (without runner)', () => {
+	it('creating a card with the minimum amount of parameters should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', null, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": null,
+			"enabled": true
+		});
+	});
+	it('creating a disabled card should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"enabled": false
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": null,
+			"enabled": false
+		});
+	});
+	it('creating a enabled card should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"enabled": true
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": null,
+			"enabled": true
+		});
+	});
+});
+// ---------------
+describe('POST /api/cards successfully (with runner)', () => {
+	let added_org;
+	let added_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);
+		added_org = res1.data
+		expect(res1.status).toEqual(200);
+		expect(res1.headers['content-type']).toContain("application/json")
+	});
+	it('creating a new runner with only needed params should return 200', async () => {
+		const res2 = await axios.post(base + '/api/runners', {
+			"firstname": "first",
+			"lastname": "last",
+			"group": added_org.id
+		}, axios_config);
+		delete res2.data.group;
+		added_runner = res2.data;
+		expect(res2.status).toEqual(200);
+		expect(res2.headers['content-type']).toContain("application/json")
+	});
+	it('creating a card with the minimum amount of parameters should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"runner": added_runner.id
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": added_runner,
+			"enabled": true
+		});
+	});
+	it('creating a card with runner (no optional params) should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"runner": added_runner.id
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": added_runner,
+			"enabled": true
+		});
+	});
+	it('creating a enabled card with runner should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"runner": added_runner.id,
+			"enabled": true
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": added_runner,
+			"enabled": true
+		});
+	});
+	it('creating a disabled card with runner should return 200', async () => {
+		const res = await axios.post(base + '/api/cards', {
+			"runner": added_runner.id,
+			"enabled": false
+		}, axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		delete res.data.id;
+		delete res.data.code;
+		expect(res.data).toEqual({
+			"runner": added_runner,
+			"enabled": false
+		});
+	});
+});
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nicolai Ort	b3ce56c605	Merge pull request 'Alpha Release 0.0.11' (#87 ) from dev into main All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details Reviewed-on: #87 Reviewed-by: Philipp Dormann <philipp@philippdormann.de>	2021-01-10 17:16:09 +00:00
Nicolai Ort	28cefa792c	Version bump All checks were successful continuous-integration/drone/pr Build is passing Details continuous-integration/drone/push Build is passing Details	2021-01-10 18:13:08 +01:00
Nicolai Ort	0803abc168	Merge pull request 'General cleanup and optimisation feature/76-cleanup' (#86 ) from feature/76-cleanup into dev All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #86	2021-01-10 17:11:31 +00:00
Nicolai Ort	02ae883fa4	Removed everything comit related from the release-it config All checks were successful continuous-integration/drone/pr Build is passing Details ref #76	2021-01-10 18:09:57 +01:00
Nicolai Ort	be4050768e	Moded group updateing to a updateusergroup action model All checks were successful continuous-integration/drone/pr Build is passing Details ref #76	2021-01-10 18:01:22 +01:00
Nicolai Ort	dc6ec23cb9	Implmented basic release mgnt ref #76	2021-01-10 17:47:31 +01:00
Nicolai Ort	1bb98c13d1	Dependency bump ref #76	2021-01-10 17:29:30 +01:00
Nicolai Ort	bca979bab5	Unified remove parameters ref #76	2021-01-10 17:16:42 +01:00
Nicolai Ort	e4fafd764c	Cleaner implementation of the api version getter ref #76	2021-01-10 17:14:42 +01:00
Nicolai Ort	172159414b	Unified the openapi generation ref #76	2021-01-10 17:10:25 +01:00
Nicolai Ort	9355138a8c	App now automagicly displays the current package version as the openapi version ref #76	2021-01-10 16:59:39 +01:00
Nicolai Ort	343cd8b772	Merge branch 'feature/76-cleanup' of git.odit.services:lfk/backend into feature/76-cleanup	2021-01-10 16:57:43 +01:00
Nicolai Ort	01e0d5b94d	Renamed the auth response call to ResponseAuth ref #76	2021-01-10 16:57:40 +01:00
Nicolai Ort	ac00667465	Renamed the auth response call to ResponseAuth ref #76	2021-01-10 16:54:19 +01:00
Nicolai Ort	3deae2bfeb	Moved all update() and toEntity action model functions to async ref #76	2021-01-10 16:53:59 +01:00
Nicolai Ort	3f7b0f6563	Renamed the update>Entity Name>() functiuons to update() ref #76	2021-01-10 16:35:52 +01:00
Nicolai Ort	e6b9d4f273	Renamed the to>Entity Name>() functiuons to toEntity() ref #76	2021-01-10 16:31:55 +01:00
Nicolai Ort	a00231dd3c	Updated imports ref #76	2021-01-10 16:23:09 +01:00
Nicolai Ort	3bc172e7e0	Intruduced a new folder structure for action models ref #76	2021-01-10 16:10:02 +01:00
Nicolai Ort	ee9df21ae5	Fixed some typos in errors ref #76	2021-01-10 16:07:37 +01:00
Nicolai Ort	f96b256ad3	Fixed some typos and extended comments for the middlewares ref #76	2021-01-10 16:03:56 +01:00
Nicolai Ort	f2c50e929e	Merge branch 'dev' of git.odit.services:lfk/backend into dev All checks were successful continuous-integration/drone/push Build is passing Details	2021-01-09 19:05:00 +01:00
Nicolai Ort	02e3239848	Reverted temporary logging	2021-01-09 19:04:07 +01:00
Nicolai Ort	8a54b027d0	Reverted temporary logging All checks were successful continuous-integration/drone/push Build is passing Details	2021-01-09 18:55:16 +01:00
Nicolai Ort	3b11e896d4	Merge branch 'dev' of git.odit.services:lfk/backend into dev All checks were successful continuous-integration/drone/push Build is passing Details	2021-01-09 18:50:50 +01:00
Nicolai Ort	89926b2c31	Temporary: extended live logging	2021-01-09 18:50:48 +01:00
Nicolai Ort	7b4e89555e	Temporary: extended live logging All checks were successful continuous-integration/drone/push Build is passing Details	2021-01-09 18:47:11 +01:00
Nicolai Ort	1e37186247	Revert "Temporary: extended live logging" This reverts commit `154c763719`.	2021-01-09 18:45:44 +01:00
Nicolai Ort	154c763719	Temporary: extended live logging All checks were successful continuous-integration/drone/push Build is passing Details ref lfk/frontend#28	2021-01-09 18:08:36 +01:00
Nicolai Ort	80197d5834	Merge pull request 'feature/78-trackscan' (#85 ) from feature/78-trackscan into dev All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #85	2021-01-09 16:33:09 +00:00
Nicolai Ort	7e95103a2d	added trackscan update tests All checks were successful continuous-integration/drone/pr Build is passing Details ref #78	2021-01-09 17:18:33 +01:00
Nicolai Ort	efe1a1f543	added trackscan delete tests ref #78	2021-01-09 16:56:57 +01:00
Nicolai Ort	4fea690670	Added missing parameter fro negative-test ref #78	2021-01-09 16:54:19 +01:00
Nicolai Ort	f1dee1061d	added trackscan get tests ref #78	2021-01-09 16:49:17 +01:00
Nicolai Ort	61cf0fc08d	Implemented proper scan invalidation ref #78	2021-01-09 16:47:54 +01:00
Nicolai Ort	0c86e5dae1	added trackscan add tests ref #78	2021-01-09 16:44:52 +01:00
Nicolai Ort	638898fa28	Implemented trackscan updateing ref #78	2021-01-09 16:17:50 +01:00
Nicolai Ort	e7cd68e1c8	removed distance checks from tests ref #78	2021-01-09 15:59:36 +01:00
Nicolai Ort	e40e6faebd	Merge branch 'feature/78-trackscan' of git.odit.services:lfk/backend into feature/78-trackscan # Conflicts: # src/controllers/RunnerController.ts	2021-01-09 15:45:35 +01:00
Nicolai Ort	3d07aac944	Implemented cascading scan, track and card deletion ref #78	2021-01-09 15:45:17 +01:00
Nicolai Ort	1a5493facf	Implemented cascading scan, track and card deletion ref #78	2021-01-09 15:43:52 +01:00
Nicolai Ort	9013b9492c	Fixed runner distance resolution ref #78	2021-01-09 15:25:11 +01:00
Nicolai Ort	188f26ad65	Fixed manual trackscan creation ref #78	2021-01-09 14:52:08 +01:00
Nicolai Ort	3ceb5a0c0f	Removed total distance from tests ref #78	2021-01-09 14:24:16 +01:00
Nicolai Ort	e1ce052d3c	Fixed runner total distance not getting resolved ref #78	2021-01-09 14:23:47 +01:00
Nicolai Ort	70a379edef	Merge pull request 'New feature: runner cards (feature/77-runner_cards)' (#84 ) from feature/77-runner_cards into dev All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #84	2021-01-09 13:01:50 +00:00
Nicolai Ort	35ea3154d1	Added card update tests All checks were successful continuous-integration/drone/pr Build is passing Details ref #77	2021-01-09 12:42:41 +01:00
Nicolai Ort	ebf66821a2	Added card delete tests ref #77	2021-01-09 12:41:59 +01:00
Nicolai Ort	8463bee253	added card add tests ref #77	2021-01-09 12:32:47 +01:00
Nicolai Ort	860680d001	Implmented the EAN generation ref #77	2021-01-09 12:24:05 +01:00
Nicolai Ort	df39166279	Added card get tests ref #77	2021-01-09 11:59:20 +01:00
Nicolai Ort	32fda46f0a	Implemented runner updateing ref #77	2021-01-09 11:55:32 +01:00
Nicolai Ort	36ecae7e6e	Added card creation #17	2021-01-09 11:48:13 +01:00
Nicolai Ort	a5bfe4e3d5	Added card deletion + errors ref #77	2021-01-09 11:28:59 +01:00
Nicolai Ort	4faeddc3f3	Added runner card get endpoints ref #77	2021-01-09 11:23:12 +01:00
Nicolai Ort	98f7bf366f	Added card permission target ref #77	2021-01-09 11:21:52 +01:00
Nicolai Ort	af3a9e5ce2	Added basic response calss for runner cards ref #77	2021-01-09 11:15:29 +01:00
Nicolai Ort	52eb7b1afe	Added a barebones runnercard controller ref #77	2021-01-09 11:10:05 +01:00
Nicolai Ort	490fbd241d	Merge pull request 'Alpha Release 0.0.10' (#83 ) from dev into main All checks were successful continuous-integration/drone/tag Build is passing Details continuous-integration/drone/push Build is passing Details Reviewed-on: #83 Reviewed-by: Philipp Dormann <philipp@philippdormann.de>	2021-01-08 20:15:27 +00:00
Nicolai Ort	f132131156	Version bump All checks were successful continuous-integration/drone/pr Build is passing Details continuous-integration/drone/push Build is passing Details	2021-01-08 21:14:20 +01:00
Nicolai Ort	c1e680a063	Fixed responsescheme for the user controller Some checks failed continuous-integration/drone/push Build is failing Details	2021-01-08 21:13:41 +01:00
Nicolai Ort	c66b06c2c9	Merge pull request 'Alpha Release 0.0.9' (#82 ) from dev into main All checks were successful continuous-integration/drone/tag Build is passing Details continuous-integration/drone/push Build is passing Details Reviewed-on: #82 Reviewed-by: Philipp Dormann <philipp@philippdormann.de>	2021-01-08 19:52:55 +00:00
Nicolai Ort	65e605cdc4	Version bump All checks were successful continuous-integration/drone/pr Build is passing Details continuous-integration/drone/push Build is passing Details	2021-01-08 20:49:19 +01:00
Nicolai Ort	d2fdb4efd9	Merge pull request 'All users get profile pics feature/79-profile_pics' (#81 ) from feature/79-profile_pics into dev Some checks failed continuous-integration/drone/push Build is failing Details Reviewed-on: #81 closes #79	2021-01-08 19:48:22 +00:00
Nicolai Ort	d0deb9d647	Fixed wrong relation getting resolved All checks were successful continuous-integration/drone/pr Build is passing Details ref #79	2021-01-08 20:40:15 +01:00
Nicolai Ort	5495c90eaf	Merge branch 'dev' into feature/79-profile_pics Some checks failed continuous-integration/drone/pr Build is failing Details	2021-01-08 20:19:08 +01:00
Nicolai Ort	bf3ffae67c	Merge pull request 'Added scan (station) apis feature/67-scan_apis' (#80 ) from feature/67-scan_apis into dev All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #80 closes #67	2021-01-08 19:18:39 +00:00
Nicolai Ort	aa0337ea33	Fixed getting all permissions for users ref #79	2021-01-08 20:17:05 +01:00
Nicolai Ort	4991d735bf	Pinned sqlite3 to 5.0.0 as a temporary bugfix All checks were successful continuous-integration/drone/pr Build is passing Details ref #67	2021-01-08 20:04:04 +01:00
Nicolai Ort	398e61bddb	Merge branch 'feature/67-scan_apis' of git.odit.services:lfk/backend into feature/67-scan_apis Some checks failed continuous-integration/drone/pr Build is failing Details # Conflicts: # .drone.yml	2021-01-08 19:37:25 +01:00
Nicolai Ort	e6576f4a54	Finned node version for ci ref #67	2021-01-08 19:37:13 +01:00
Nicolai Ort	c3b9e135b0	Finned node version for ci Some checks failed continuous-integration/drone/pr Build is failing Details ref #67	2021-01-08 19:34:39 +01:00
Nicolai Ort	3bd4948c43	Merge branch 'feature/79-profile_pics' of git.odit.services:lfk/backend into feature/79-profile_pics	2021-01-08 19:32:13 +01:00
Nicolai Ort	f3cd1380be	First part of the permission return (buggy!) ref #79	2021-01-08 19:32:11 +01:00
Nicolai Ort	a2c3dfbf85	First part of the permission return (buggy!) ref #71	2021-01-08 19:32:04 +01:00
Nicolai Ort	3c37aafe1f	Added profile pics to all user related models ref #79	2021-01-08 19:11:50 +01:00
Nicolai Ort	c591c182b3	Updated comments Some checks failed continuous-integration/drone/pr Build is failing Details ref #67	2021-01-08 18:37:33 +01:00
Nicolai Ort	9cc50078d1	Merge branch 'dev' into feature/67-scan_apis	2021-01-08 18:29:33 +01:00
Nicolai Ort	7728759bcd	Added openapi sec scheme for the scan station auth ref #67	2021-01-08 18:28:35 +01:00
Nicolai Ort	ce8fed350e	Updated OPENAPI Descriptions for the new controllers ref #67	2021-01-08 18:25:29 +01:00
Nicolai Ort	a005945e9e	Added scan add tests with the station based auth ref #67	2021-01-08 18:09:47 +01:00
Nicolai Ort	cf86520fae	Fixed wrong auth type being used ref #67	2021-01-08 18:08:13 +01:00
Nicolai Ort	db6fdf6baf	Implemented scan auth middleware ref #67	2021-01-08 17:50:29 +01:00
Nicolai Ort	975ad50afc	Added scan update tests ref #67	2021-01-08 17:42:05 +01:00
Nicolai Ort	0c27df7754	Added scan add tests ref #67	2021-01-08 17:27:56 +01:00
Nicolai Ort	102a860ba3	Added scan delete tests ref #67	2021-01-08 16:47:52 +01:00
Nicolai Ort	3a886714a0	Merge branch 'feature/67-scan_apis' of git.odit.services:lfk/backend into feature/67-scan_apis # Conflicts: # src/tests/scanstations/scanstations_delete.spec.ts	2021-01-07 20:35:05 +01:00
Nicolai Ort	09ab638239	Added scan station delete tests ref #67	2021-01-07 20:34:48 +01:00
Nicolai Ort	a4f88c78f4	Added scan station delete tests ref #67	2021-01-07 20:34:36 +01:00
Nicolai Ort	ccf2a3b617	Added scan station update tests ref #67	2021-01-07 20:31:29 +01:00
Nicolai Ort	c8f941a779	Fixed wrong error getting thrown ref #67	2021-01-07 20:22:58 +01:00
Nicolai Ort	5510cbb8e9	Added scan station add tests ref #67	2021-01-07 20:16:14 +01:00
Nicolai Ort	a434173b54	Added scan station get tests ref #67	2021-01-07 20:04:15 +01:00
Nicolai Ort	7387f700fb	Added alias for posting track scans ref #67	2021-01-07 19:46:20 +01:00
Nicolai Ort	4f01baaa23	Added the enabled flag for scanstations ref #67	2021-01-07 19:37:15 +01:00
Nicolai Ort	09b37f0ff2	Fixed typo ref #67	2021-01-07 19:36:57 +01:00
Nicolai Ort	324d5709e3	Added tmp files to gitignore ref #67	2021-01-07 19:19:21 +01:00
Nicolai Ort	3f23e4f1f1	Added scan get tests ref #67	2021-01-07 19:18:26 +01:00
Nicolai Ort	9776a35f9f	Track deletion now recognizes associated stations ref #67	2021-01-07 18:53:09 +01:00
Nicolai Ort	9b9ee70288	Implemented cascading station deletion ref #67	2021-01-07 18:48:58 +01:00
Nicolai Ort	2628f69651	Implemented scan station creation ref #67	2021-01-07 18:39:38 +01:00
Nicolai Ort	b9c0a32862	Implemented single scan station get +e errors ref #67	2021-01-07 18:35:19 +01:00
Nicolai Ort	82644a2ff4	Implmented getting all scan stations ref #67	2021-01-07 18:05:54 +01:00
Nicolai Ort	3d2c93b5ac	Added (scan) stations as a new permission target ref #67	2021-01-07 17:35:36 +01:00
Nicolai Ort	c447114297	Added a ScanStation response class ref #67	2021-01-07 17:31:44 +01:00
Nicolai Ort	857de9ffcc	Added Creation class for ScanSatations ref #67	2021-01-07 17:29:22 +01:00
Nicolai Ort	eea656bd7b	Added a barebones scanstation controller ref #67	2021-01-07 17:16:36 +01:00
Nicolai Ort	eec5284306	Implemented "normal" scan updateing ref #67	2021-01-07 17:12:12 +01:00
Nicolai Ort	88a6a768c4	Implemented scan deletion ref #67	2021-01-07 17:03:40 +01:00
Nicolai Ort	edac1a224c	Fixed runner scan validation bug ref #67	2021-01-07 16:59:57 +01:00
Nicolai Ort	e67d1c5697	Fixed scan runner in response ref #67	2021-01-07 16:38:41 +01:00
Nicolai Ort	30502ec949	Fixed Creation of normal scans ref #67	2021-01-07 16:32:16 +01:00
Nicolai Ort	a2c3913601	Merge branch 'feature/67-scan_apis' of git.odit.services:lfk/backend into feature/67-scan_apis	2021-01-07 16:13:44 +01:00
Nicolai Ort	f1c7713da2	Adusted the way scan distances are implemented ref #67	2021-01-07 16:13:41 +01:00
Nicolai Ort	d6a41d5a82	Ajusted the way scan distances are implemented	2021-01-07 16:13:31 +01:00
Nicolai Ort	72b5ca4153	Added basics for scan creation (to be tested after scanstations got added) ref #67	2021-01-06 19:44:20 +01:00
Nicolai Ort	aeec2e1c32	Added single scan get w/ errors ref #67	2021-01-03 19:36:38 +01:00
Nicolai Ort	f9889bea3d	Implemented scans get including the response classes ref #67	2021-01-03 19:26:06 +01:00
Nicolai Ort	2cad2ac2e9	Implemented the second round of the toResponse normalisationf for all classes ref #67	2021-01-03 19:18:31 +01:00
Nicolai Ort	58156e0d61	Implemented the first route of the toResponse normalisationf for all classes ref #67	2021-01-03 19:09:06 +01:00
Nicolai Ort	a4b0dfe43e	Defined responses for scans and trackscans ref #67	2021-01-03 19:02:06 +01:00
Nicolai Ort	ee2433a5ae	Added barebones scans controller ref #67	2021-01-03 18:49:33 +01:00
Nicolai Ort	2151b8502d	Added Scan permission target ref #67	2021-01-03 18:48:05 +01:00