Merge pull request 'Alpha Release 0.3.1' (#127 ) from dev into main

Reviewed-on: #127 Reviewed-by: Philipp Dormann <philipp@philippdormann.de>
🧾New changelog file version [CI SKIP] [skip ci]
2021-01-27 16:43:26 +00:00 · 2021-01-27 16:32:04 +00:00 · 2021-01-27 16:31:45 +00:00 · 2021-01-27 16:31:16 +00:00 · 2021-01-26 19:15:59 +00:00 · 2021-01-26 20:15:35 +01:00
105 changed files with 3565 additions and 936 deletions
--- a/.drone.yml
+++ b/.drone.yml
@@ -90,11 +90,20 @@ trigger:
 kind: pipeline
 type: docker
 name: build:latest
+clone:
+  disable: true

 steps:
+  - name: clone
+    image: alpine/git
+    commands:
+      - git clone $DRONE_REMOTE_URL .
+      - git checkout dev
+      - git merge main
+      - git checkout main
  - name: build latest
+    depends_on: ["clone"]
    image: plugins/docker
-    depends_on: [clone]
    settings:
      username:
        from_secret: DOCKER_REGISTRY_USER
@@ -104,6 +113,15 @@ steps:
      tags:
        - latest
      registry: registry.odit.services
+  - name: push merge to repo
+    depends_on: ["clone"]
+    image: appleboy/drone-git-push
+    settings:
+      branch: dev
+      commit: false
+      remote: git@git.odit.services:lfk/backend.git
+      ssh_key:
+        from_secret: GITLAB_SSHKEY

 trigger:
  branch:
--- a/.env.ci
+++ b/.env.ci
@@ -6,4 +6,4 @@ DB_USER=unused
 DB_PASSWORD=bla
 DB_NAME=./test.sqlite
 NODE_ENV=dev
-POSTALCODE_COUNTRYCODE=null
+POSTALCODE_COUNTRYCODE=DE
--- a/.env.example
+++ b/.env.example
@@ -1,9 +1,10 @@
 APP_PORT=4010
-DB_TYPE=bla
+DB_TYPE=sqlite
 DB_HOST=bla
 DB_PORT=bla
 DB_USER=bla
 DB_PASSWORD=bla
-DB_NAME=bla
+DB_NAME=./test.sqlite
 NODE_ENV=production
-POSTALCODE_COUNTRYCODE=null
+POSTALCODE_COUNTRYCODE=DE
+SEED_TEST_DATA=false
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,8 +2,191 @@

 All notable changes to this project will be documented in this file. Dates are displayed in UTC.

+#### [v0.3.1](https://git.odit.services/lfk/backend/compare/v0.3.0...v0.3.1)
+
+- Merge pull request 'new advanced endpoints feature/125-team_runner' (#126) from feature/125-team_runner into dev [`870fd47`](https://git.odit.services/lfk/backend/commit/870fd47c83389345d7b24a15df6a4e61e930d140)
+- Added get runners by team test [`69417e9`](https://git.odit.services/lfk/backend/commit/69417e93c081422561db1e211b12f32e539010ce)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`71898d5`](https://git.odit.services/lfk/backend/commit/71898d576c2620d2f2e2b4336e62f1d04a443201)
+- Created the organizations/runners endpoint [`570c34b`](https://git.odit.services/lfk/backend/commit/570c34bed04e359f389a8f427486bf92891f1dcb)
+- Created the runnerTeam/runners endpoint [`7be2971`](https://git.odit.services/lfk/backend/commit/7be2971a9e02bf0e784f7fe5cdd82afbbbf7f854)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`aedfcfc`](https://git.odit.services/lfk/backend/commit/aedfcfcc8359afd7dba4fa5e515e8e77fbb3fc6e)
+- Added get runners by org test [`f71a22f`](https://git.odit.services/lfk/backend/commit/f71a22f4dd9bf14d39ced91908f6f6a5d8395e56)
+- 🚀Bumped version to v0.3.1 [`db08760`](https://git.odit.services/lfk/backend/commit/db0876015bf0599dabb21357f172735888c79aa8)
+
+#### [v0.3.0](https://git.odit.services/lfk/backend/compare/v0.2.1...v0.3.0)
+
+> 24 January 2021
+
+- Merge pull request 'Alpha Release 0.3.0' (#122) from dev into main [`c964591`](https://git.odit.services/lfk/backend/commit/c9645918398e62a80341d038b6b6b5c60ee4b1c7)
+- Renamed files and classed from *Organisation* to *Organization*📝 [`c6c643e`](https://git.odit.services/lfk/backend/commit/c6c643ecf125f5fdf58b105f97efad32e8545dd4)
+- Changed organisation* to organization* in descriptions, comments and endoints ✏ [`ef15d0d`](https://git.odit.services/lfk/backend/commit/ef15d0d57619d79e014e0c0331965ca2bc664254)
+- Added registration invalid citizen tests [`81d2197`](https://git.odit.services/lfk/backend/commit/81d2197a3e978ca43bc79720c32d75f8490f08df)
+- Implemented registration key generation [`ad44650`](https://git.odit.services/lfk/backend/commit/ad446500f90f945aadc3510377bcfd2123440da0)
+- Implemented a runner selfservice registration creation action [`10af1ba`](https://git.odit.services/lfk/backend/commit/10af1ba34148c992e94fa580e1c0210bfaea5112)
+- Created a citizenrunner selfservice create action [`6df195b`](https://git.odit.services/lfk/backend/commit/6df195b6ec5fde27f84cbe54992558715b843b87)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`5660aec`](https://git.odit.services/lfk/backend/commit/5660aecb50c0e6dd538850c6375d2f692fb7a1f2)
+- Implemented a registration key for organisations [`d490247`](https://git.odit.services/lfk/backend/commit/d490247d1e337a680b385d2115e82f79ba54a601)
+- Updates old tests to the new ss-ktokens [`a9843ed`](https://git.odit.services/lfk/backend/commit/a9843ed4598485e6e3d18e78b876b6e000ea6e38)
+- Added self-service get invalid tests [`e964a8e`](https://git.odit.services/lfk/backend/commit/e964a8ed44109899516c4d3b0dc35fe4990107a1)
+- Implemented runner selfservice token generation [`c39a59e`](https://git.odit.services/lfk/backend/commit/c39a59e54ef0b1cc891684283422805af38969e3)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`cc4bf44`](https://git.odit.services/lfk/backend/commit/cc4bf4451cf4eac0e0f1bab02119c2dd5e300f48)
+- Renamedpermisssions from *Organisation* to *Organization*📝 [`cd7e9b8`](https://git.odit.services/lfk/backend/commit/cd7e9b86b4b9d3e1ef0312f6fff436fcef4a5c94)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`3697783`](https://git.odit.services/lfk/backend/commit/3697783e190e36f1168132d75da1eca7be27b4f6)
+- Merge pull request 'OrganiZation rename feature/117-organization' (#121) from feature/117-organization into dev [`161feaf`](https://git.odit.services/lfk/backend/commit/161feaf364195c7b85041e06cdefef72d75b8951)
+- Added registration valid company tests [`20e102e`](https://git.odit.services/lfk/backend/commit/20e102ec5c52c6a01144d064c96b8b2bd1ccfd00)
+- Added registration invalid company tests [`29aeb04`](https://git.odit.services/lfk/backend/commit/29aeb046de769e37fd7257507e36337237697ea0)
+- Added registration valid citizentests [`72941da`](https://git.odit.services/lfk/backend/commit/72941da1cb1c31fd6bfcba2ee3704f34bdd73ef0)
+- Citizen runners now have to provide an email address for verification [`dee3639`](https://git.odit.services/lfk/backend/commit/dee36395a69da6c5e1bc4e94bd705b0418a6a3ff)
+- Implemented the basics for the runner selfservice registration endpoint [`5288c70`](https://git.odit.services/lfk/backend/commit/5288c701c1ac880f3c8b7ece01457aae4bac87d7)
+- Added selfservice get positive test [`0c87906`](https://git.odit.services/lfk/backend/commit/0c87906cc3fa5feaf1d7c186f68d978d4ed7fa8e)
+- Fixed tests testing for a old responseclass [`45c8bb8`](https://git.odit.services/lfk/backend/commit/45c8bb83be0814bed8856a617de435f4694db76c)
+- Fixed typo [`46f9503`](https://git.odit.services/lfk/backend/commit/46f9503543ee011d0780caeefa95748e4be45f58)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`c5d0646`](https://git.odit.services/lfk/backend/commit/c5d0646c425f83689bffd862edd568ca0c1b5ad8)
+- Added registration invalid company tests [`e5b6f65`](https://git.odit.services/lfk/backend/commit/e5b6f650b25af776a543f7f9c7ccf0000bf07a66)
+- Marked param as optional (default: false) [`f8d7544`](https://git.odit.services/lfk/backend/commit/f8d754451769e8361ec2367df7bc586f8fffe8eb)
+- Bugfix: turned old entity in response to responseclass [`10f98e9`](https://git.odit.services/lfk/backend/commit/10f98e9c992b1fb45334e65082d7c47af214b6ac)
+- Resolved missing relation [`3b2ed3f`](https://git.odit.services/lfk/backend/commit/3b2ed3f0f2557dccddf6ba656b201c196cc24bf0)
+- Fixed fluctuating test bahaviour [`1227408`](https://git.odit.services/lfk/backend/commit/1227408407ac66b9689446c1f318b453a9d45069)
+- 🚀Bumped version to v0.3.0 [`75e2a44`](https://git.odit.services/lfk/backend/commit/75e2a44c9c7f720d1a5a20611b305e5d56a9155b)
+- Merge pull request 'Self service registration feature/112-selfservice_registration' (#120) from feature/112-selfservice_registration into dev [`6a66dd8`](https://git.odit.services/lfk/backend/commit/6a66dd803becb59172e8645c6b55898fb4b4c0b5)
+- Implemented the citizen runner self-registration endpoint [`1b5465b`](https://git.odit.services/lfk/backend/commit/1b5465bea810f59cbf8bb1a3e82c062176f79c49)
+- Citizen registration now returns tokens [`9dd9304`](https://git.odit.services/lfk/backend/commit/9dd9304a71eae94978710cf9db82dc030ca7a37d)
+- Fixed wrong error getting thrown [`6469e3b`](https://git.odit.services/lfk/backend/commit/6469e3bc976c589b42fbac4a95bbee84f67244ee)
+- Updated response schema error to a more fitting one [`5a00394`](https://git.odit.services/lfk/backend/commit/5a003945ac7d1a8d446c1bcc8007523b675ab6f5)
+- Added check for empty token for runner self-service get [`6434b4d`](https://git.odit.services/lfk/backend/commit/6434b4dfce2da307d66ec5670d570d66ea8af8f8)
+- Specified uft-8 format for string [`34c852b`](https://git.odit.services/lfk/backend/commit/34c852b12aaa88e64efa1e0575361c09652e22e1)
+- MAde uuid column unique [`7b00b19`](https://git.odit.services/lfk/backend/commit/7b00b19fce3189069bcdbe0d2bcf91322506eb2b)
+- Updated Method of removeing the team of citizen runners [`946efef`](https://git.odit.services/lfk/backend/commit/946efef2523c5ceb627b5c465343422cd985832d)
+- Added openapi description [`73b1114`](https://git.odit.services/lfk/backend/commit/73b1114883ed2b87ef523130de4c5ca90a11c856)
+
+#### [v0.2.1](https://git.odit.services/lfk/backend/compare/v0.2.0...v0.2.1)
+
+> 21 January 2021
+
+- Merge pull request 'Alpha Release 0.2.1' (#119) from dev into main [`b441658`](https://git.odit.services/lfk/backend/commit/b44165857016c3ecdf0dffe8d324d572524d10ed)
+- Created a donation runner response class for the runner selfservice [`88a7089`](https://git.odit.services/lfk/backend/commit/88a7089289e35be4468cb952b311fcb15c54c5a1)
+- Readme reorganisation [skip ci] [`e2ec0a3`](https://git.odit.services/lfk/backend/commit/e2ec0a3b64a7388ae85d557dfb66354d70cd1b72)
+- Added a seeder for runner test data [`9df9d9a`](https://git.odit.services/lfk/backend/commit/9df9d9ae80277d5ccc753639badb48c4afb13088)
+- Created a donation respoinse class for the runner selfservice [`b89f7ac`](https://git.odit.services/lfk/backend/commit/b89f7ac1b4ddd6e53e6e2e8330c1fa2170b48591)
+- Added barebones controller for the runner info selfservice [`2274b47`](https://git.odit.services/lfk/backend/commit/2274b476d6caa1de91bb13b6944f8dc233cf446e)
+- Implemented a method for getting the runner object from a jwt [`8079769`](https://git.odit.services/lfk/backend/commit/80797698818f456c7746523d5a4f66267fdab10d)
+- Added key-value like db table for config flags [`b15967f`](https://git.odit.services/lfk/backend/commit/b15967ff3162e9fe3a634a6f4fc5669f2314cc21)
+- Added a /runners/id/scans endpoint [`a82fc0f`](https://git.odit.services/lfk/backend/commit/a82fc0fb9e9c3cbdc6be299b27164c0811e58775)
+- Now creating a test contact [`1837336`](https://git.odit.services/lfk/backend/commit/1837336865893ca39d3bc628ff3c57e018a8555d)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`02677de`](https://git.odit.services/lfk/backend/commit/02677de5c07b2ac5dcff5567655130ba1b1d48cf)
+- The data seeding now only get's triggered on the first time thx to using the key-value [`7bc6030`](https://git.odit.services/lfk/backend/commit/7bc603028dc60d26ffc5327868afbce512966d4d)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`3a93c9c`](https://git.odit.services/lfk/backend/commit/3a93c9c078af38ba837b55bf4590867dfd401955)
+- Added a "onlyValid" query param [`b5f3dec`](https://git.odit.services/lfk/backend/commit/b5f3dec93bfe4180abbe9ce74094cb1269d0e686)
+- Added a citizen org seeder [`2db6510`](https://git.odit.services/lfk/backend/commit/2db6510a8ad83300b286a3bd35ca4db103da72d1)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`d528134`](https://git.odit.services/lfk/backend/commit/d5281348b6f3bd6f2e6936ee4497860699b8c3c6)
+- 📖New license file version [CI SKIP] [skip ci] [`d8b6669`](https://git.odit.services/lfk/backend/commit/d8b6669d126e64d9e434b5f841ae17a02117822b)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`e95c457`](https://git.odit.services/lfk/backend/commit/e95c457e444e9d2e99c2af8b6ee369c36d4ca8ea)
+- Beautified import [`c5f7cb2`](https://git.odit.services/lfk/backend/commit/c5f7cb2c68dbee0ab1e0361754f4d4b876666c82)
+- 🚀Bumped version to v0.2.1 [`6de9d54`](https://git.odit.services/lfk/backend/commit/6de9d547b736c4538dac5254353d483576337290)
+- Merge pull request 'Runner scans endpoint feature/113-runner_scans' (#116) from feature/113-runner_scans into dev [`36d01a0`](https://git.odit.services/lfk/backend/commit/36d01a0a890eb74428679ec6c4fcb14708aaa9fe)
+- Added get tests for the /runner/scans endpoint [`26dff4f`](https://git.odit.services/lfk/backend/commit/26dff4f41829e8571231aff3c5d0e3a7c53559d8)
+- Implemented the get part of the runner selfservice (no jwts are availdable yet (tm) [`da1fe34`](https://git.odit.services/lfk/backend/commit/da1fe34249a741115c1aeedcade16c5c852e896b)
+- Fixed the bool converter for null values [`e12aedd`](https://git.odit.services/lfk/backend/commit/e12aedd1aad6de1f934e9593dda4607a303b2eb5)
+- Added a config option for test data seeding [`67ba489`](https://git.odit.services/lfk/backend/commit/67ba489fe2f2a2706d640a668cd0e675ded6a7df)
+- SEED_TEST_DATA is now false by default [`8870ebd`](https://git.odit.services/lfk/backend/commit/8870ebdb5e6d9045222440abc2c047929a74b520)
+- Added sqlite as to env.sample db of choice [skip ci] [`f4668b6`](https://git.odit.services/lfk/backend/commit/f4668b6e81d7aeac62e24291ffcb39b00ea44aac)
+- Merge pull request 'Runner selfservice info endpoint feature/111-runner_selfservic_info' (#115) from feature/111-runner_selfservic_info into dev [`1717df1`](https://git.odit.services/lfk/backend/commit/1717df113edeab2d2628041ee1eccc27380fd379)
+- Merge pull request 'Implemented more seeding feature/110-seeding' (#114) from feature/110-seeding into dev [`886c109`](https://git.odit.services/lfk/backend/commit/886c1092d60f8e39357e3b841ed01bb082ede2c4)
+- Updated the openapi description [`1915697`](https://git.odit.services/lfk/backend/commit/191569792c9a5cee93718555bba4e7679e4391af)
+- Fixed wrong amount calculation [`4ee8079`](https://git.odit.services/lfk/backend/commit/4ee807973e1995681ec549f7c482bc5514a6ec55)
+- Added bool conversion for testdata seeding env var [`c18012f`](https://git.odit.services/lfk/backend/commit/c18012f65a704e07acd56870c9ed9f6d06cf97a9)
+- Now also seeding runners to the test org [`eab0e63`](https://git.odit.services/lfk/backend/commit/eab0e634a26c1a80e7fa2ccb9dc368f0760b2fd8)
+
+#### [v0.2.0](https://git.odit.services/lfk/backend/compare/v0.1.1...v0.2.0)
+
+> 20 January 2021
+
+- Merge pull request 'Alpha Release 0.2.0' (#109) from dev into main [`dd3d93e`](https://git.odit.services/lfk/backend/commit/dd3d93edc7db7ca7f133cb2d8f60c3eaf30bcbf0)
+- Updated contact update tests [`c3d008e`](https://git.odit.services/lfk/backend/commit/c3d008ec0ff92f80addbdb93ffc1fa2b3278a8a6)
+- Added contact delete tests [`dd7e5da`](https://git.odit.services/lfk/backend/commit/dd7e5dae368a8decd79357f658dda2164fa6f1e7)
+- Added contact add valid tests [`e165f01`](https://git.odit.services/lfk/backend/commit/e165f019307e7745357493eacf3e2fa31538122b)
+- Cleaned up var names [`a3c93f0`](https://git.odit.services/lfk/backend/commit/a3c93f0d394833f1a6f78d862b094ca751c85561)
+- Added address update ivalid tests [`427dfaa`](https://git.odit.services/lfk/backend/commit/427dfaafabd243e94aba27c2dec2705fd8ed5d64)
+- Added barebones contact controller from donor-controller [`3e7190e`](https://git.odit.services/lfk/backend/commit/3e7190e279181c5f99d890ca141489b24908b904)
+- Added first address update tests [`4d40225`](https://git.odit.services/lfk/backend/commit/4d40225a4491e8eb3f41ef0fd558a599f63729be)
+- Added a contact update class [`c172aa8`](https://git.odit.services/lfk/backend/commit/c172aa8bf8083500828743ed696955a1fe3caef2)
+- Added address update valid tests [`230cdb0`](https://git.odit.services/lfk/backend/commit/230cdb0e37e2b7a21e7feb156f2b91a69ad200fd)
+- Implemented deep address validation [`9dc9ce3`](https://git.odit.services/lfk/backend/commit/9dc9ce37d8fbfc92842e4e05bbde68398324a186)
+- Added contact add invalid tests [`940d62c`](https://git.odit.services/lfk/backend/commit/940d62cde4cf7be7780904d681a5e4c9efaa2ba5)
+- Added a contact response class [`1407fe3`](https://git.odit.services/lfk/backend/commit/1407fe36f3637d6c53024c48788b318d985f8960)
+- Removed old create address class [`2a465f8`](https://git.odit.services/lfk/backend/commit/2a465f88c58c0b4be3ecd99d96a04c177a40b312)
+- Switched the create classes over to the new address implementation [`2cd15d2`](https://git.odit.services/lfk/backend/commit/2cd15d25e934a5439bfea4de901f136e360e17f6)
+- Added contact get tests [`b002cf2`](https://git.odit.services/lfk/backend/commit/b002cf2df1eafc722fbfb51b3bffb02bee002305)
+- Test's now accept the new address format [`8dbee32`](https://git.odit.services/lfk/backend/commit/8dbee32eeec8ee3d013e4446e8f53544ee4cb577)
+- Implemented the get endpoints [`ab70f7e`](https://git.odit.services/lfk/backend/commit/ab70f7e49893344dde8f5af93f571a5d67818e19)
+- Implemented contact deletion [`0379786`](https://git.odit.services/lfk/backend/commit/0379786cbda057ad95d709fa135d34beb0db8de1)
+- Removed the IAddressUser Interface entity [`e265172`](https://git.odit.services/lfk/backend/commit/e2651728c5abf2273bf51a7652c51d55d8fa0a2f)
+- Implemented contact updateing [`28fb983`](https://git.odit.services/lfk/backend/commit/28fb9834e18bde012c5b51cc49a39585d20f7cc1)
+- Fixed key null constraint [`de82437`](https://git.odit.services/lfk/backend/commit/de824375d3a1da6ee4d78ea39b7da66fc05f2a02)
+- Implemented contact posting [`11af9c0`](https://git.odit.services/lfk/backend/commit/11af9c02d977dcd6919652256dbdb9fd5438cabd)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`8960aa5`](https://git.odit.services/lfk/backend/commit/8960aa5545ddeb57d4ef42c21c0ca6001dfeaea9)
+- Implemented contact group setting on creation [`3b06d1a`](https://git.odit.services/lfk/backend/commit/3b06d1a6ef3c95eb5bb7d485accddabba0a8e4f7)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`32e054e`](https://git.odit.services/lfk/backend/commit/32e054eb84c869210fd483583ae5a6d0e2249cf9)
+- Switched Address to embedded entity [`7fbe649`](https://git.odit.services/lfk/backend/commit/7fbe649dc90f4bb9f240c5a80fed447048e5e105)
+- Removed the address errors [`58ae9b5`](https://git.odit.services/lfk/backend/commit/58ae9b589aef3580f4b8558c3d5ddbd7171e7915)
+- Switched the update classes over to the new address implementation [`d0df5dd`](https://git.odit.services/lfk/backend/commit/d0df5dd641ac17f1fd8ad6bd8b46afa9dd2745c3)
+- Updated the contact errors [`a9a5eb6`](https://git.odit.services/lfk/backend/commit/a9a5eb673570bb3c0d1a55bb1292e208493663bd)
+- Implemented adress deletion (through reset) [`57b9c2b`](https://git.odit.services/lfk/backend/commit/57b9c2babcd68d69d1cbb240a86c2897717ba758)
+- Fixed donor address check [`4824547`](https://git.odit.services/lfk/backend/commit/4824547dde4d7f90e9e2377a26df34cabf082fdb)
+- Updated contact delete tests [`8ae53f1`](https://git.odit.services/lfk/backend/commit/8ae53f1c4930e2fd72eb230a5314336f3a45a611)
+- Added address to contact response [`09e429f`](https://git.odit.services/lfk/backend/commit/09e429fc676c7dd370bba0495b072f81867bd250)
+- Updated the responseclasses to use the new address implementation [`dafac06`](https://git.odit.services/lfk/backend/commit/dafac06bc84d1b237096a561b3adcd3ca5cb1dd8)
+- Added address validity check [`ae7c5ff`](https://git.odit.services/lfk/backend/commit/ae7c5ff0c387e9337d01a9dd819a4dddc208f6dd)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`da9a359`](https://git.odit.services/lfk/backend/commit/da9a3592510eacd2d67a127dc61e954343e0444b)
+- 🚀Bumped version to v0.2.0 [`ddafd90`](https://git.odit.services/lfk/backend/commit/ddafd90d3e41fb9ee37172a8306c30d8483dfe2c)
+- Merge pull request 'Implemented group contacts feature/104-contacts' (#108) from feature/104-contacts into dev [`a0c2b5a`](https://git.odit.services/lfk/backend/commit/a0c2b5ade8d198ec16d33b39e47205e8b03a669f)
+- Updated comments [`a4e8311`](https://git.odit.services/lfk/backend/commit/a4e8311cbd22588ecb4dc2fdbe05397b07d336f8)
+- Removed (now useless) relations [`673dea2`](https://git.odit.services/lfk/backend/commit/673dea2e5754e99ff77f7556d4fc03d4cca28a94)
+- Added missing id property [`6b4b16c`](https://git.odit.services/lfk/backend/commit/6b4b16c13b0c2f55745ded3431cad2f4986be296)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`f53894b`](https://git.odit.services/lfk/backend/commit/f53894b16ac1c06ecbeeb0b63a56ac438b2fbe1b)
+- Updated comments [`8bc01d3`](https://git.odit.services/lfk/backend/commit/8bc01d3f2406ce8e58c2ab2963c858495c510dcf)
+- Fixed contact cascading [`179c2a5`](https://git.odit.services/lfk/backend/commit/179c2a5157fca036acf8d0e6a51821d377860bc1)
+- Added openapi description about non-deletion [`56c73c2`](https://git.odit.services/lfk/backend/commit/56c73c2555d4d12ffb088ec5550667022d3a8694)
+- Added contact permission target [`d12801e`](https://git.odit.services/lfk/backend/commit/d12801e34d57cec0e867f69123e3be39ed2fe2f5)
+- Adjusted env sample [`a1acd35`](https://git.odit.services/lfk/backend/commit/a1acd3519f66965202da0cd15df61a807230619c)
+- Renamed controller to better fit the overall nameing scheme [`d743f7e`](https://git.odit.services/lfk/backend/commit/d743f7ee1277256ada8fe39f900349ff2643118a)
+- Fixed column not getting resolved [`2b658ac`](https://git.odit.services/lfk/backend/commit/2b658ac381f318cf37fc2051ea3e83976e3c5773)
+- Fixed column not getting resolved [`321d291`](https://git.odit.services/lfk/backend/commit/321d291b4bf983ff4930cadecf3a013430a97649)
+- Set country code for the ci env to DE [`30b585c`](https://git.odit.services/lfk/backend/commit/30b585c0c12b3b9818778110d33d5b3ab84d4192)
+- Implemented postal code validation for the validaton function [`f245840`](https://git.odit.services/lfk/backend/commit/f245840cde5726611197b00730aca72ea133c427)
+- Fixed push undefined eror [`2eb26e4`](https://git.odit.services/lfk/backend/commit/2eb26e4e381a97fd829a294501fa42ac7b712b56)
+- Merge pull request 'Fully implemented addresses feature/105-addresses' (#107) from feature/105-addresses into dev [`5e36855`](https://git.odit.services/lfk/backend/commit/5e368552ea810ea1d3963b1207ba98f7b46c4abc)
+
+#### [v0.1.1](https://git.odit.services/lfk/backend/compare/v0.1.0...v0.1.1)
+
+> 16 January 2021
+
+- Merge pull request 'Alpha Release 0.1.1 - Hotfix release' (#106) from dev into main [`7533c34`](https://git.odit.services/lfk/backend/commit/7533c349ef98ed328151259fca68621b3eb5fd98)
+- 🚀Bumped version to v0.1.1 [`9445c6f`](https://git.odit.services/lfk/backend/commit/9445c6f21e376329b9200664a44a94ba1f1dd463)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`1b9d296`](https://git.odit.services/lfk/backend/commit/1b9d2969ebdca4dca84898b1e8307be7b781b90b)
+- Implemented the /me controller that allows a user to get and update themselves [`8ef5f90`](https://git.odit.services/lfk/backend/commit/8ef5f90abda97a73d5c5a7767a144ac3fb5288c1)
+- Implemented a baisc user checker/getter [`f1db883`](https://git.odit.services/lfk/backend/commit/f1db8836092269966a7f54e69b1f20c171e81b21)
+- Implemented getting own permissions [`4f6e816`](https://git.odit.services/lfk/backend/commit/4f6e81677c81c852e735407295c634b43b317479)
+- Hotfix: Missing relation bug [`6e6979c`](https://git.odit.services/lfk/backend/commit/6e6979cfe3660056cff6b9eabc194852234ac0a6)
+- Hotfix: Missing relation bug [`b167ba0`](https://git.odit.services/lfk/backend/commit/b167ba07f79709a2c3b33c5546c52659c42863f3)
+- automaticly merge main into dev after building a latest image [`02efb9a`](https://git.odit.services/lfk/backend/commit/02efb9a8e55831ecce4109e17b2f07a56e491fd5)
+- User deletion now requires confirmation [`6b7ecd3`](https://git.odit.services/lfk/backend/commit/6b7ecd3044c45b2eed46ee5010bed4dab4f02df9)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`3766899`](https://git.odit.services/lfk/backend/commit/3766899c8393545a89986a98dafd542edc4a1d39)
+- Created barebones file for the userchecker [`e586a11`](https://git.odit.services/lfk/backend/commit/e586a11e2ad42af9c9bb5d2a47f48e3306fe49b2)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`6febb99`](https://git.odit.services/lfk/backend/commit/6febb994990b4cab7ee54b0368f74dd95664bfdf)
+- Updated descriptions and responses [`fc7b8f4`](https://git.odit.services/lfk/backend/commit/fc7b8f4c16cef0e72b04f096d5a17d4144b5feb7)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`50b893f`](https://git.odit.services/lfk/backend/commit/50b893f5370902ccc40f8bb45ed160103400f529)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`de36a24`](https://git.odit.services/lfk/backend/commit/de36a24191a8cdc4ff6b23637ea9f91109b59bbb)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`91569ce`](https://git.odit.services/lfk/backend/commit/91569ced40402a63017a90a01efaf48578b5c806)
+- Merge pull request 'User self-management feature/100-me_endpoints' (#103) from feature/100-me_endpoints into dev [`a6c7d54`](https://git.odit.services/lfk/backend/commit/a6c7d54fe72ffe23add926afa0be150a7a370099)
+- Moved the me endpoints to /users/me [`f9834b5`](https://git.odit.services/lfk/backend/commit/f9834b5f4d80b11ee5f7773b339dd421341c6e7f)
+- Moved optional param to being optional [`a334adf`](https://git.odit.services/lfk/backend/commit/a334adffc6d07c8ab340263123e00a96f21acecb)
+
 #### [v0.1.0](https://git.odit.services/lfk/backend/compare/v0.0.12...v0.1.0)

+> 15 January 2021
+
+- Merge pull request 'First feature version 0.1.0' (#102) from dev into main [`38b9a77`](https://git.odit.services/lfk/backend/commit/38b9a772cd2d1c1e6298ae449d07db7c555a00e9)
 - Removed useless parts from functions and updated comments [`c05834f`](https://git.odit.services/lfk/backend/commit/c05834f2a13eb838efbf61be803e4e320561718e)
 - Switched tests over to the new id-only schema [`d88fb18`](https://git.odit.services/lfk/backend/commit/d88fb183198e66cadf5290c1ef7b7e4ccedad4f0)
 - 🧾New changelog file version [CI SKIP] [skip ci] [`0e119e4`](https://git.odit.services/lfk/backend/commit/0e119e48340cd0a602a08da727b480aa2fe5500c)
@@ -24,6 +207,7 @@ All notable changes to this project will be documented in this file. Dates are d
 - 🧾New changelog file version [CI SKIP] [skip ci] [`dc6ad9c`](https://git.odit.services/lfk/backend/commit/dc6ad9cdd3d8f29ef9a15bf7ac61c7c55c57e9fb)
 - 🧾New changelog file version [CI SKIP] [skip ci] [`d1a0bed`](https://git.odit.services/lfk/backend/commit/d1a0bed00e01a0e9d8ba1165e3c6ca3dd910bd00)
 - Clarified comments [`1b799a6`](https://git.odit.services/lfk/backend/commit/1b799a697305791c3f67ac4a738c7287d1ac553e)
+- 🧾New changelog file version [CI SKIP] [skip ci] [`6184304`](https://git.odit.services/lfk/backend/commit/618430433d03012c2cad5be6021cf1ea8fdf9624)
 - 🧾New changelog file version [CI SKIP] [skip ci] [`8218a45`](https://git.odit.services/lfk/backend/commit/8218a452bdf7550ec1eed2b0045e94ea4ae91d31)
 - 🚀Bumped version to v0.1.0 [`80c5f9b`](https://git.odit.services/lfk/backend/commit/80c5f9b84de355b4408dcffd632589a9a0e4ad2e)
 - 🧾New changelog file version [CI SKIP] [skip ci] [`79f46cb`](https://git.odit.services/lfk/backend/commit/79f46cb745e4cb4bdac7dbb6c6c2b8fdc9867592)
--- a/README.md
+++ b/README.md
@@ -2,20 +2,18 @@

 Backend Server

+## Quickstart 🐳
+> Use this to run the backend with a postgresql db in docker
+
+1. Clone the repo or copy the docker-compose 
+2. Run in toe folder that contains the docker-compose file: `docker-compose up -d`
+3. Visit http://127.0.0.1:4010/api/docs to check if the server is running
+4. You can now use the default admin user (`demo:demo`)
+
 ## Dev Setup 🛠
+> Local dev setup utilizing sqlite3 as the database.

-### Local w/ sqlite
-
-1. Create a .env file in the project root containing:
-   ```
-    APP_PORT=4010
-    DB_TYPE=sqlite
-    DB_HOST=bla
-    DB_PORT=bla
-    DB_USER=bla
-    DB_PASSWORD=bla
-    DB_NAME=./test.sqlite
-   ```
+1. Rename the .env.example file to .env (you can adjust app port and other settings, if needed)
 2. Install Dependencies
   ```bash
   yarn
@@ -25,15 +23,21 @@ Backend Server
   yarn dev
   ```

-### Generate Docs
-```
-yarn docs
-```
-
-### Docker w/ postgres 🐳
-
+### Run Tests
 ```bash
-docker-compose up --build
+# Run tests once (server has to run)
+yarn test
+
+# Run test in watch mode (reruns on change)
+yarn test:watch
+
+# Run test in ci mode (automaticly starts the dev server)
+yarn test:ci
+```
+
+### Generate Docs
+```bash
+yarn docs
 ```

 ## Recommended Editor
@@ -42,22 +46,19 @@ docker-compose up --build

 ### Recommended Extensions

- will be automatically recommended via ./vscode/extensions.json
+* will be automatically recommended via ./vscode/extensions.json

-## Branches
- main: Protected "release" branch
- dev: Current dev branch for merging the different features - only push for merges or minor changes!
- feature/xyz: Feature branches - `feature/issueid-title`
- bugfix/xyz: Branches for bugfixes - `bugfix/issueid-title` (no id for readme changes needed)
-
-
-## File Structure
-
- src/models/entities\* - database models (typeorm entities)
- src/models/actions\* - actions models
- src/models/responses\* - response models
- src/controllers/\* - routing-controllers
- src/loaders/\* - loaders for the different init steps of the api server
- src/middlewares/\* - express middlewares (mainly auth r/n)
- src/errors/* - our custom (http) errors
- src/routes/\* - express routes for everything we don't do via routing-controllers (depreciated)
+## Staging
+### Branches & Tags
+* vX.Y.Z: Release tags created from the main branch
+   * The version numbers follow the semver standard
+   * A new release tag automaticly triggers the release ci pipeline
+* main: Protected "release" branch
+   * The latest tag of the docker image get's build from this
+   * New releases get created as tags from this   
+* dev: Current dev branch for merging the different feature branches and bugfixes
+   * The dev tag of the docker image get's build from this
+   * Only push minor changes to this branch!
+   * To merge a feature branch into this please create a pull request
+* feature/xyz: Feature branches - nameing scheme: `feature/issueid-title`
+* bugfix/xyz: Branches for bugfixes - nameing scheme:`bugfix/issueid-title`
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@odit/lfk-backend",
-  "version": "0.1.0",
+  "version": "0.3.1",
  "main": "src/app.ts",
  "repository": "https://git.odit.services/lfk/backend",
  "author": {
--- a/src/app.ts
+++ b/src/app.ts
@@ -5,10 +5,12 @@ import { config, e as errors } from './config';
 import loaders from "./loaders/index";
 import authchecker from "./middlewares/authchecker";
 import { ErrorHandler } from './middlewares/ErrorHandler';
+import UserChecker from './middlewares/UserChecker';

 const CONTROLLERS_FILE_EXTENSION = process.env.NODE_ENV === 'production' ? 'js' : 'ts';
 const app = createExpressServer({
  authorizationChecker: authchecker,
+  currentUserChecker: UserChecker,
  middlewares: [ErrorHandler],
  development: config.development,
  cors: true,
--- a/src/config.ts
+++ b/src/config.ts
@@ -9,7 +9,8 @@ export const config = {
    jwt_secret: process.env.JWT_SECRET || "secretjwtsecret",
    phone_validation_countrycode: getPhoneCodeLocale(),
    postalcode_validation_countrycode: getPostalCodeLocale(),
-    version: process.env.VERSION || require('../package.json').version
+    version: process.env.VERSION || require('../package.json').version,
+    seedTestData: getDataSeeding()
 }
 let errors = 0
 if (typeof config.internal_port !== "number") {
@@ -30,4 +31,11 @@ function getPostalCodeLocale(): any {
        return null;
    }
 }
+function getDataSeeding(): Boolean {
+    try {
+        return JSON.parse(process.env.SEED_TEST_DATA);
+    } catch (error) {
+        return false;
+    }
+}
 export let e = errors
--- a/src/controllers/GroupContactController.ts
+++ b/src/controllers/GroupContactController.ts
@@ -0,0 +1,107 @@
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnection, getConnectionManager, Repository } from 'typeorm';
+import { GroupContactIdsNotMatchingError, GroupContactNotFoundError } from '../errors/GroupContactErrors';
+import { RunnerGroupNotFoundError } from '../errors/RunnerGroupErrors';
+import { CreateGroupContact } from '../models/actions/create/CreateGroupContact';
+import { UpdateGroupContact } from '../models/actions/update/UpdateGroupContact';
+import { GroupContact } from '../models/entities/GroupContact';
+import { RunnerGroup } from '../models/entities/RunnerGroup';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseGroupContact } from '../models/responses/ResponseGroupContact';
+
+@JsonController('/contacts')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class GroupContactController {
+	private contactRepository: Repository<GroupContact>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.contactRepository = getConnectionManager().get().getRepository(GroupContact);
+	}
+
+	@Get()
+	@Authorized("CONTACT:GET")
+	@ResponseSchema(ResponseGroupContact, { isArray: true })
+	@OpenAPI({ description: 'Lists all contacts. <br> This includes the contact\'s associated groups.' })
+	async getAll() {
+		let responseContacts: ResponseGroupContact[] = new Array<ResponseGroupContact>();
+		const contacts = await this.contactRepository.find({ relations: ['groups', 'groups.parentGroup'] });
+		contacts.forEach(contact => {
+			responseContacts.push(contact.toResponse());
+		});
+		return responseContacts;
+	}
+
+	@Get('/:id')
+	@Authorized("CONTACT:GET")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(GroupContactNotFoundError, { statusCode: 404 })
+	@OnUndefined(GroupContactNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the contact whose id got provided. <br> This includes the contact\'s associated groups.' })
+	async getOne(@Param('id') id: number) {
+		let contact = await this.contactRepository.findOne({ id: id }, { relations: ['groups', 'groups.parentGroup'] })
+		if (!contact) { throw new GroupContactNotFoundError(); }
+		return contact.toResponse();
+	}
+
+	@Post()
+	@Authorized("CONTACT:CREATE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(RunnerGroupNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new contact.' })
+	async post(@Body({ validate: true }) createContact: CreateGroupContact) {
+		let contact;
+		try {
+			contact = await createContact.toEntity();
+		} catch (error) {
+			throw error;
+		}
+
+		contact = await this.contactRepository.save(contact)
+		return (await this.contactRepository.findOne({ id: contact.id }, { relations: ['groups', 'groups.parentGroup'] })).toResponse();
+	}
+
+	@Put('/:id')
+	@Authorized("CONTACT:UPDATE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(GroupContactNotFoundError, { statusCode: 404 })
+	@ResponseSchema(GroupContactIdsNotMatchingError, { statusCode: 406 })
+	@ResponseSchema(RunnerGroupNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: "Update the contact whose id you provided. <br> Please remember that ids can't be changed." })
+	async put(@Param('id') id: number, @Body({ validate: true }) contact: UpdateGroupContact) {
+		let oldContact = await this.contactRepository.findOne({ id: id });
+
+		if (!oldContact) {
+			throw new GroupContactNotFoundError();
+		}
+
+		if (oldContact.id != contact.id) {
+			throw new GroupContactIdsNotMatchingError();
+		}
+
+		await this.contactRepository.save(await contact.update(oldContact));
+		return (await this.contactRepository.findOne({ id: contact.id }, { relations: ['groups', 'groups.parentGroup'] })).toResponse();
+	}
+
+	@Delete('/:id')
+	@Authorized("CONTACT:DELETE")
+	@ResponseSchema(ResponseGroupContact)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the contact whose id you provided. <br> If no contact with this id exists it will just return 204(no content). <br> This won\'t delete any groups associated with the contact.' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let contact = await this.contactRepository.findOne({ id: id });
+		if (!contact) { return null; }
+		const responseContact = await this.contactRepository.findOne(contact, { relations: ['groups', 'groups.parentGroup'] });
+		for (let group of responseContact.groups) {
+			group.contact = null;
+			await getConnection().getRepository(RunnerGroup).save(group);
+		}
+
+		await this.contactRepository.delete(contact);
+		return responseContact.toResponse();
+	}
+}
--- a/src/controllers/ImportController.ts
+++ b/src/controllers/ImportController.ts
@@ -36,7 +36,7 @@ export class ImportController {
        return responseRunners;
    }

-    @Post('/organisations/:id/import')
+    @Post('/organizations/:id/import')
    @ContentType("application/json")
    @ResponseSchema(ResponseRunner, { isArray: true, statusCode: 200 })
    @ResponseSchema(RunnerGroupNotFoundError, { statusCode: 404 })
@@ -78,7 +78,7 @@ export class ImportController {
        return await this.postJSON(importRunners, groupID);
    }

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

+	@Get('/:id/scans')
+	@Authorized(["RUNNER:GET", "SCAN:GET"])
+	@ResponseSchema(ResponseScan, { isArray: true })
+	@ResponseSchema(ResponseTrackScan, { isArray: true })
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Lists all scans of the runner whose id got provided. <br> If you only want the valid scans just add the ?onlyValid=true query param.' })
+	async getScans(@Param('id') id: number, onlyValid?: boolean) {
+		let responseScans: ResponseScan[] = new Array<ResponseScan>();
+		let runner = await this.runnerRepository.findOne({ id: id }, { relations: ['scans', 'scans.track', 'scans.station', 'scans.runner'] })
+		if (!runner) { throw new RunnerNotFoundError(); }
+
+		if (!onlyValid) {
+			for (let scan of runner.scans) {
+				responseScans.push(scan.toResponse());
+			}
+		}
+		else {
+			for (let scan of runner.validScans) {
+				responseScans.push(scan.toResponse());
+			}
+		}
+
+		return responseScans;
+	}
+
 	@Post()
 	@Authorized("RUNNER:CREATE")
 	@ResponseSchema(ResponseRunner)
--- a/src/controllers/RunnerOrganisationController.ts
+++ b/src/controllers/RunnerOrganisationController.ts
@@ -1,127 +0,0 @@
-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 { RunnerOrganisationHasRunnersError, RunnerOrganisationHasTeamsError, RunnerOrganisationIdsNotMatchingError, RunnerOrganisationNotFoundError } from '../errors/RunnerOrganisationErrors';
-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';
-import { RunnerController } from './RunnerController';
-import { RunnerTeamController } from './RunnerTeamController';
-
-
-@JsonController('/organisations')
-@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
-export class RunnerOrganisationController {
-	private runnerOrganisationRepository: Repository<RunnerOrganisation>;
-
-	/**
-	 * Gets the repository of this controller's model/entity.
-	 */
-	constructor() {
-		this.runnerOrganisationRepository = getConnectionManager().get().getRepository(RunnerOrganisation);
-	}
-
-	@Get()
-	@Authorized("ORGANISATION:GET")
-	@ResponseSchema(ResponseRunnerOrganisation, { isArray: true })
-	@OpenAPI({ description: 'Lists all organisations. <br> This includes their address, contact and teams (if existing/associated).' })
-	async getAll() {
-		let responseTeams: ResponseRunnerOrganisation[] = new Array<ResponseRunnerOrganisation>();
-		const runners = await this.runnerOrganisationRepository.find({ relations: ['address', 'contact', 'teams'] });
-		runners.forEach(runner => {
-			responseTeams.push(new ResponseRunnerOrganisation(runner));
-		});
-		return responseTeams;
-	}
-
-	@Get('/:id')
-	@Authorized("ORGANISATION:GET")
-	@ResponseSchema(ResponseRunnerOrganisation)
-	@ResponseSchema(RunnerOrganisationNotFoundError, { statusCode: 404 })
-	@OnUndefined(RunnerOrganisationNotFoundError)
-	@OpenAPI({ description: 'Lists all information about the organisation whose id got provided.' })
-	async getOne(@Param('id') id: number) {
-		let runnerOrg = await this.runnerOrganisationRepository.findOne({ id: id }, { relations: ['address', 'contact', 'teams'] });
-		if (!runnerOrg) { throw new RunnerOrganisationNotFoundError(); }
-		return new ResponseRunnerOrganisation(runnerOrg);
-	}
-
-	@Post()
-	@Authorized("ORGANISATION:CREATE")
-	@ResponseSchema(ResponseRunnerOrganisation)
-	@OpenAPI({ description: 'Create a new organsisation.' })
-	async post(@Body({ validate: true }) createRunnerOrganisation: CreateRunnerOrganisation) {
-		let runnerOrganisation;
-		try {
-			runnerOrganisation = await createRunnerOrganisation.toEntity();
-		} catch (error) {
-			throw error;
-		}
-
-		runnerOrganisation = await this.runnerOrganisationRepository.save(runnerOrganisation);
-
-		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(runnerOrganisation, { relations: ['address', 'contact', 'teams'] }));
-	}
-
-	@Put('/:id')
-	@Authorized("ORGANISATION:UPDATE")
-	@ResponseSchema(ResponseRunnerOrganisation)
-	@ResponseSchema(RunnerOrganisationNotFoundError, { statusCode: 404 })
-	@ResponseSchema(RunnerOrganisationIdsNotMatchingError, { statusCode: 406 })
-	@OpenAPI({ description: "Update the organisation whose id you provided. <br> Please remember that ids can't be changed." })
-	async put(@Param('id') id: number, @Body({ validate: true }) updateOrganisation: UpdateRunnerOrganisation) {
-		let oldRunnerOrganisation = await this.runnerOrganisationRepository.findOne({ id: id });
-
-		if (!oldRunnerOrganisation) {
-			throw new RunnerOrganisationNotFoundError();
-		}
-
-		if (oldRunnerOrganisation.id != updateOrganisation.id) {
-			throw new RunnerOrganisationIdsNotMatchingError();
-		}
-
-		await this.runnerOrganisationRepository.save(await updateOrganisation.update(oldRunnerOrganisation));
-
-		return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['address', 'contact', 'teams'] }));
-	}
-
-	@Delete('/:id')
-	@Authorized("ORGANISATION:DELETE")
-	@ResponseSchema(ResponseRunnerOrganisation)
-	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
-	@ResponseSchema(RunnerOrganisationHasTeamsError, { statusCode: 406 })
-	@ResponseSchema(RunnerOrganisationHasRunnersError, { statusCode: 406 })
-	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the organsisation whose id you provided. <br> If the organisation still has runners and/or teams associated this will fail. <br> To delete the organisation with all associated runners and teams set the force QueryParam to true (cascading deletion might take a while). <br> If no organisation with this id exists it will just return 204(no content).' })
-	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
-		let organisation = await this.runnerOrganisationRepository.findOne({ id: id });
-		if (!organisation) { return null; }
-		let runnerOrganisation = await this.runnerOrganisationRepository.findOne(organisation, { relations: ['address', 'contact', 'runners', 'teams'] });
-
-		if (!force) {
-			if (runnerOrganisation.teams.length != 0) {
-				throw new RunnerOrganisationHasTeamsError();
-			}
-		}
-		const teamController = new RunnerTeamController()
-		for (let team of runnerOrganisation.teams) {
-			await teamController.remove(team.id, true);
-		}
-
-		if (!force) {
-			if (runnerOrganisation.runners.length != 0) {
-				throw new RunnerOrganisationHasRunnersError();
-			}
-		}
-		const runnerController = new RunnerController()
-		for (let runner of runnerOrganisation.runners) {
-			await runnerController.remove(runner.id, true);
-		}
-
-		const responseOrganisation = new ResponseRunnerOrganisation(runnerOrganisation);
-		await this.runnerOrganisationRepository.delete(organisation);
-		return responseOrganisation;
-	}
-}
--- a/src/controllers/RunnerOrganizationController.ts
+++ b/src/controllers/RunnerOrganizationController.ts
@@ -0,0 +1,145 @@
+import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnectionManager, Repository } from 'typeorm';
+import { RunnerOrganizationHasRunnersError, RunnerOrganizationHasTeamsError, RunnerOrganizationIdsNotMatchingError, RunnerOrganizationNotFoundError } from '../errors/RunnerOrganizationErrors';
+import { CreateRunnerOrganization } from '../models/actions/create/CreateRunnerOrganization';
+import { UpdateRunnerOrganization } from '../models/actions/update/UpdateRunnerOrganization';
+import { Runner } from '../models/entities/Runner';
+import { RunnerOrganization } from '../models/entities/RunnerOrganization';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
+import { ResponseRunner } from '../models/responses/ResponseRunner';
+import { ResponseRunnerOrganization } from '../models/responses/ResponseRunnerOrganization';
+import { RunnerController } from './RunnerController';
+import { RunnerTeamController } from './RunnerTeamController';
+
+
+@JsonController('/organizations')
+@OpenAPI({ security: [{ "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+export class RunnerOrganizationController {
+	private runnerOrganizationRepository: Repository<RunnerOrganization>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.runnerOrganizationRepository = getConnectionManager().get().getRepository(RunnerOrganization);
+	}
+
+	@Get()
+	@Authorized("ORGANIZATION:GET")
+	@ResponseSchema(ResponseRunnerOrganization, { isArray: true })
+	@OpenAPI({ description: 'Lists all organizations. <br> This includes their address, contact and teams (if existing/associated).' })
+	async getAll() {
+		let responseTeams: ResponseRunnerOrganization[] = new Array<ResponseRunnerOrganization>();
+		const runners = await this.runnerOrganizationRepository.find({ relations: ['contact', 'teams'] });
+		runners.forEach(runner => {
+			responseTeams.push(new ResponseRunnerOrganization(runner));
+		});
+		return responseTeams;
+	}
+
+	@Get('/:id')
+	@Authorized("ORGANIZATION:GET")
+	@ResponseSchema(ResponseRunnerOrganization)
+	@ResponseSchema(RunnerOrganizationNotFoundError, { statusCode: 404 })
+	@OnUndefined(RunnerOrganizationNotFoundError)
+	@OpenAPI({ description: 'Lists all information about the organization whose id got provided.' })
+	async getOne(@Param('id') id: number) {
+		let runnerOrg = await this.runnerOrganizationRepository.findOne({ id: id }, { relations: ['contact', 'teams'] });
+		if (!runnerOrg) { throw new RunnerOrganizationNotFoundError(); }
+		return new ResponseRunnerOrganization(runnerOrg);
+	}
+
+	@Get('/:id/runners')
+	@Authorized(["RUNNER:GET", "SCAN:GET"])
+	@ResponseSchema(ResponseRunner, { isArray: true })
+	@ResponseSchema(RunnerOrganizationNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Lists all runners from this org and it\'s teams (if you don\'t provide the ?onlyDirect=true param). <br> This includes the runner\'s group and distance ran.' })
+	async getRunners(@Param('id') id: number, @QueryParam('onlyDirect') onlyDirect: boolean) {
+		let responseRunners: ResponseRunner[] = new Array<ResponseRunner>();
+		let runners: Runner[];
+		if (!onlyDirect) { runners = (await this.runnerOrganizationRepository.findOne({ id: id }, { relations: ['runners', 'runners.group', 'runners.scans', 'runners.scans.track', 'teams', 'teams.runners', 'teams.runners.group', 'teams.runners.scans', 'teams.runners.scans.track'] })).allRunners; }
+		else { runners = (await this.runnerOrganizationRepository.findOne({ id: id }, { relations: ['runners', 'runners.group', 'runners.scans', 'runners.scans.track'] })).runners; }
+		runners.forEach(runner => {
+			responseRunners.push(new ResponseRunner(runner));
+		});
+		return responseRunners;
+	}
+
+	@Post()
+	@Authorized("ORGANIZATION:CREATE")
+	@ResponseSchema(ResponseRunnerOrganization)
+	@OpenAPI({ description: 'Create a new organsisation.' })
+	async post(@Body({ validate: true }) createRunnerOrganization: CreateRunnerOrganization) {
+		let runnerOrganization;
+		try {
+			runnerOrganization = await createRunnerOrganization.toEntity();
+		} catch (error) {
+			throw error;
+		}
+
+		runnerOrganization = await this.runnerOrganizationRepository.save(runnerOrganization);
+
+		return new ResponseRunnerOrganization(await this.runnerOrganizationRepository.findOne(runnerOrganization, { relations: ['contact', 'teams'] }));
+	}
+
+	@Put('/:id')
+	@Authorized("ORGANIZATION:UPDATE")
+	@ResponseSchema(ResponseRunnerOrganization)
+	@ResponseSchema(RunnerOrganizationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(RunnerOrganizationIdsNotMatchingError, { statusCode: 406 })
+	@OpenAPI({ description: "Update the organization whose id you provided. <br> Please remember that ids can't be changed." })
+	async put(@Param('id') id: number, @Body({ validate: true }) updateOrganization: UpdateRunnerOrganization) {
+		let oldRunnerOrganization = await this.runnerOrganizationRepository.findOne({ id: id });
+
+		if (!oldRunnerOrganization) {
+			throw new RunnerOrganizationNotFoundError();
+		}
+
+		if (oldRunnerOrganization.id != updateOrganization.id) {
+			throw new RunnerOrganizationIdsNotMatchingError();
+		}
+
+		await this.runnerOrganizationRepository.save(await updateOrganization.update(oldRunnerOrganization));
+
+		return new ResponseRunnerOrganization(await this.runnerOrganizationRepository.findOne(id, { relations: ['contact', 'teams'] }));
+	}
+
+	@Delete('/:id')
+	@Authorized("ORGANIZATION:DELETE")
+	@ResponseSchema(ResponseRunnerOrganization)
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(RunnerOrganizationHasTeamsError, { statusCode: 406 })
+	@ResponseSchema(RunnerOrganizationHasRunnersError, { statusCode: 406 })
+	@OnUndefined(204)
+	@OpenAPI({ description: 'Delete the organsisation whose id you provided. <br> If the organization still has runners and/or teams associated this will fail. <br> To delete the organization with all associated runners and teams set the force QueryParam to true (cascading deletion might take a while). <br> This won\'t delete the associated contact. <br> If no organization with this id exists it will just return 204(no content).' })
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		let organization = await this.runnerOrganizationRepository.findOne({ id: id });
+		if (!organization) { return null; }
+		let runnerOrganization = await this.runnerOrganizationRepository.findOne(organization, { relations: ['contact', 'runners', 'teams'] });
+
+		if (!force) {
+			if (runnerOrganization.teams.length != 0) {
+				throw new RunnerOrganizationHasTeamsError();
+			}
+		}
+		const teamController = new RunnerTeamController()
+		for (let team of runnerOrganization.teams) {
+			await teamController.remove(team.id, true);
+		}
+
+		if (!force) {
+			if (runnerOrganization.runners.length != 0) {
+				throw new RunnerOrganizationHasRunnersError();
+			}
+		}
+		const runnerController = new RunnerController()
+		for (let runner of runnerOrganization.runners) {
+			await runnerController.remove(runner.id, true);
+		}
+
+		const responseOrganization = new ResponseRunnerOrganization(runnerOrganization);
+		await this.runnerOrganizationRepository.delete(organization);
+		return responseOrganization;
+	}
+}
--- a/src/controllers/RunnerSelfServiceController.ts
+++ b/src/controllers/RunnerSelfServiceController.ts
@@ -0,0 +1,98 @@
+import * as jwt from "jsonwebtoken";
+import { Body, Get, JsonController, OnUndefined, Param, Post } from 'routing-controllers';
+import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+import { getConnectionManager, Repository } from 'typeorm';
+import { config } from '../config';
+import { InvalidCredentialsError, JwtNotProvidedError } from '../errors/AuthError';
+import { RunnerEmailNeededError, RunnerNotFoundError } from '../errors/RunnerErrors';
+import { RunnerOrganizationNotFoundError } from '../errors/RunnerOrganizationErrors';
+import { JwtCreator } from '../jwtcreator';
+import { CreateSelfServiceCitizenRunner } from '../models/actions/create/CreateSelfServiceCitizenRunner';
+import { CreateSelfServiceRunner } from '../models/actions/create/CreateSelfServiceRunner';
+import { Runner } from '../models/entities/Runner';
+import { RunnerGroup } from '../models/entities/RunnerGroup';
+import { RunnerOrganization } from '../models/entities/RunnerOrganization';
+import { ResponseSelfServiceRunner } from '../models/responses/ResponseSelfServiceRunner';
+
+
+@JsonController('/runners')
+export class RunnerSelfServiceController {
+	private runnerRepository: Repository<Runner>;
+	private orgRepository: Repository<RunnerOrganization>;
+
+	/**
+	 * Gets the repository of this controller's model/entity.
+	 */
+	constructor() {
+		this.runnerRepository = getConnectionManager().get().getRepository(Runner);
+		this.orgRepository = getConnectionManager().get().getRepository(RunnerOrganization);
+	}
+
+	@Get('/me/:jwt')
+	@ResponseSchema(ResponseSelfServiceRunner)
+	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@OnUndefined(RunnerNotFoundError)
+	@OpenAPI({ description: 'Lists all information about yourself. <br> Please provide your runner jwt(that code we gave you during registration) for auth. <br> If you lost your jwt/personalized link please contact support.' })
+	async get(@Param('jwt') token: string) {
+		return (new ResponseSelfServiceRunner(await this.getRunner(token)));
+	}
+
+	@Post('/register')
+	@ResponseSchema(ResponseSelfServiceRunner)
+	@ResponseSchema(RunnerEmailNeededError, { statusCode: 406 })
+	@OpenAPI({ description: 'Create a new selfservice runner in the citizen org. <br> This endpoint shoud be used to allow "everyday citizen" to register themselves. <br> You have to provide a mail address, b/c the future we\'ll implement email verification.' })
+	async registerRunner(@Body({ validate: true }) createRunner: CreateSelfServiceCitizenRunner) {
+		let runner = await createRunner.toEntity();
+
+		runner = await this.runnerRepository.save(runner);
+		let response = new ResponseSelfServiceRunner(await this.runnerRepository.findOne(runner, { relations: ['scans', 'group', 'group.parentGroup', 'scans.track', 'cards', 'distanceDonations', 'distanceDonations.donor', 'distanceDonations.runner', 'distanceDonations.runner.scans', 'distanceDonations.runner.scans.track'] }));
+		response.token = JwtCreator.createSelfService(runner);
+		return response;
+	}
+
+	@Post('/register/:token')
+	@ResponseSchema(ResponseSelfServiceRunner)
+	@ResponseSchema(RunnerOrganizationNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Create a new selfservice runner in a provided org. <br> The orgs get provided and authorized via api tokens that can be optained via the /organizations endpoint.' })
+	async registerOrganizationRunner(@Param('token') token: string, @Body({ validate: true }) createRunner: CreateSelfServiceRunner) {
+		const org = await this.getOrgansisation(token);
+
+		let runner = await createRunner.toEntity(org);
+		runner = await this.runnerRepository.save(runner);
+
+		let response = new ResponseSelfServiceRunner(await this.runnerRepository.findOne(runner, { relations: ['scans', 'group', 'group.parentGroup', 'scans.track', 'cards', 'distanceDonations', 'distanceDonations.donor', 'distanceDonations.runner', 'distanceDonations.runner.scans', 'distanceDonations.runner.scans.track'] }));
+		response.token = JwtCreator.createSelfService(runner);
+		return response;
+	}
+
+	/**
+	 * Get's a runner by a provided jwt token.
+	 * @param token The runner jwt provided by the runner to identitfy themselves.
+	 */
+	private async getRunner(token: string): Promise<Runner> {
+		if (token == "") { throw new JwtNotProvidedError(); }
+		let jwtPayload = undefined
+		try {
+			jwtPayload = <any>jwt.verify(token, config.jwt_secret);
+		} catch (error) {
+			throw new InvalidCredentialsError();
+		}
+
+		const runner = await this.runnerRepository.findOne({ id: jwtPayload["id"] }, { relations: ['scans', 'group', 'group.parentGroup', 'scans.track', 'cards', 'distanceDonations', 'distanceDonations.donor', 'distanceDonations.runner', 'distanceDonations.runner.scans', 'distanceDonations.runner.scans.track'] });
+		if (!runner) { throw new RunnerNotFoundError() }
+		return runner;
+	}
+
+	/**
+	 * Get's a runner org by a provided registration api key.
+	 * @param token The organization's registration api token.
+	 */
+	private async getOrgansisation(token: string): Promise<RunnerGroup> {
+		token = Buffer.from(token, 'base64').toString('utf8');
+
+		const organization = await this.orgRepository.findOne({ key: token });
+		if (!organization) { throw new RunnerOrganizationNotFoundError; }
+
+		return organization;
+	}
+}
--- a/src/controllers/RunnerTeamController.ts
+++ b/src/controllers/RunnerTeamController.ts
@@ -6,6 +6,7 @@ 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 { ResponseRunner } from '../models/responses/ResponseRunner';
 import { ResponseRunnerTeam } from '../models/responses/ResponseRunnerTeam';
 import { RunnerController } from './RunnerController';

@@ -25,7 +26,7 @@ export class RunnerTeamController {
 	@Get()
 	@Authorized("TEAM:GET")
 	@ResponseSchema(ResponseRunnerTeam, { isArray: true })
-	@OpenAPI({ description: 'Lists all teams. <br> This includes their parent organisation and contact (if existing/associated).' })
+	@OpenAPI({ description: 'Lists all teams. <br> This includes their parent organization and contact (if existing/associated).' })
 	async getAll() {
 		let responseTeams: ResponseRunnerTeam[] = new Array<ResponseRunnerTeam>();
 		const runners = await this.runnerTeamRepository.find({ relations: ['parentGroup', 'contact'] });
@@ -47,6 +48,20 @@ export class RunnerTeamController {
 		return new ResponseRunnerTeam(runnerTeam);
 	}

+	@Get('/:id/runners')
+	@Authorized(["RUNNER:GET", "SCAN:GET"])
+	@ResponseSchema(ResponseRunner, { isArray: true })
+	@ResponseSchema(RunnerTeamNotFoundError, { statusCode: 404 })
+	@OpenAPI({ description: 'Lists all runners from this team. <br> This includes the runner\'s group and distance ran.' })
+	async getRunners(@Param('id') id: number) {
+		let responseRunners: ResponseRunner[] = new Array<ResponseRunner>();
+		const runners = (await this.runnerTeamRepository.findOne({ id: id }, { relations: ['runners', 'runners.group', 'runners.scans', 'runners.scans.track'] })).runners;
+		runners.forEach(runner => {
+			responseRunners.push(new ResponseRunner(runner));
+		});
+		return responseRunners;
+	}
+
 	@Post()
 	@Authorized("TEAM:CREATE")
 	@ResponseSchema(ResponseRunnerTeam)
@@ -93,7 +108,7 @@ export class RunnerTeamController {
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@ResponseSchema(RunnerTeamHasRunnersError, { statusCode: 406 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the team whose id you provided. <br> If the team still has runners associated this will fail. <br> To delete the team with all associated runners set the force QueryParam to true (cascading deletion might take a while). <br> If no team with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the team whose id you provided. <br> If the team still has runners associated this will fail. <br> To delete the team with all associated runners set the force QueryParam to true (cascading deletion might take a while). <br> This won\'t delete the associated contact.<br> If no team with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
 		let team = await this.runnerTeamRepository.findOne({ id: id });
 		if (!team) { return null; }
--- a/src/controllers/StatsController.ts
+++ b/src/controllers/StatsController.ts
@@ -4,12 +4,12 @@ import { getConnection } from 'typeorm';
 import StatsAuth from '../middlewares/StatsAuth';
 import { Donation } from '../models/entities/Donation';
 import { Runner } from '../models/entities/Runner';
-import { RunnerOrganisation } from '../models/entities/RunnerOrganisation';
+import { RunnerOrganization } from '../models/entities/RunnerOrganization';
 import { RunnerTeam } from '../models/entities/RunnerTeam';
 import { Scan } from '../models/entities/Scan';
 import { User } from '../models/entities/User';
 import { ResponseStats } from '../models/responses/ResponseStats';
-import { ResponseStatsOrgnisation } from '../models/responses/ResponseStatsOrganisation';
+import { ResponseStatsOrgnisation } from '../models/responses/ResponseStatsOrganization';
 import { ResponseStatsRunner } from '../models/responses/ResponseStatsRunner';
 import { ResponseStatsTeam } from '../models/responses/ResponseStatsTeam';

@@ -23,7 +23,7 @@ export class StatsController {
        let connection = getConnection();
        let runners = await connection.getRepository(Runner).find({ relations: ['scans', 'scans.track'] });
        let teams = await connection.getRepository(RunnerTeam).find();
-        let orgs = await connection.getRepository(RunnerOrganisation).find();
+        let orgs = await connection.getRepository(RunnerOrganization).find();
        let users = await connection.getRepository(User).find();
        let scans = await connection.getRepository(Scan).find();
        let donations = await connection.getRepository(Donation).find({ relations: ['runner', 'runner.scans', 'runner.scans.track'] });
@@ -94,12 +94,12 @@ export class StatsController {
        return responseTeams;
    }

-    @Get("/organisations/distance")
+    @Get("/organizations/distance")
    @UseBefore(StatsAuth)
    @ResponseSchema(ResponseStatsOrgnisation, { isArray: true })
-    @OpenAPI({ description: "Returns the top ten organisations by distance.", security: [{ "StatsApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+    @OpenAPI({ description: "Returns the top ten organizations by distance.", security: [{ "StatsApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
    async getTopOrgsByDistance() {
-        let orgs = await getConnection().getRepository(RunnerOrganisation).find({ relations: ['runners', 'runners.scans', 'runners.distanceDonations', 'runners.scans.track', 'teams', 'teams.runners', 'teams.runners.scans', 'teams.runners.distanceDonations', 'teams.runners.scans.track'] });
+        let orgs = await getConnection().getRepository(RunnerOrganization).find({ relations: ['runners', 'runners.scans', 'runners.distanceDonations', 'runners.scans.track', 'teams', 'teams.runners', 'teams.runners.scans', 'teams.runners.distanceDonations', 'teams.runners.scans.track'] });
        let topOrgs = orgs.sort((org1, org2) => org1.distance - org2.distance).slice(0, 9);
        let responseOrgs: ResponseStatsOrgnisation[] = new Array<ResponseStatsOrgnisation>();
        topOrgs.forEach(org => {
@@ -108,12 +108,12 @@ export class StatsController {
        return responseOrgs;
    }

-    @Get("/organisations/donations")
+    @Get("/organizations/donations")
    @UseBefore(StatsAuth)
    @ResponseSchema(ResponseStatsOrgnisation, { isArray: true })
-    @OpenAPI({ description: "Returns the top ten organisations by donations.", security: [{ "StatsApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
+    @OpenAPI({ description: "Returns the top ten organizations by donations.", security: [{ "StatsApiToken": [] }, { "AuthToken": [] }, { "RefreshTokenCookie": [] }] })
    async getTopOrgsByDonations() {
-        let orgs = await getConnection().getRepository(RunnerOrganisation).find({ relations: ['runners', 'runners.scans', 'runners.distanceDonations', 'runners.scans.track', 'teams', 'teams.runners', 'teams.runners.scans', 'teams.runners.distanceDonations', 'teams.runners.scans.track'] });
+        let orgs = await getConnection().getRepository(RunnerOrganization).find({ relations: ['runners', 'runners.scans', 'runners.distanceDonations', 'runners.scans.track', 'teams', 'teams.runners', 'teams.runners.scans', 'teams.runners.distanceDonations', 'teams.runners.scans.track'] });
        let topOrgs = orgs.sort((org1, org2) => org1.distanceDonationAmount - org2.distanceDonationAmount).slice(0, 9);
        let responseOrgs: ResponseStatsOrgnisation[] = new Array<ResponseStatsOrgnisation>();
        topOrgs.forEach(org => {
--- a/src/controllers/UserController.ts
+++ b/src/controllers/UserController.ts
@@ -1,7 +1,7 @@
 import { Authorized, Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { UserIdsNotMatchingError, UsernameContainsIllegalCharacterError, UserNotFoundError } from '../errors/UserErrors';
+import { UserDeletionNotConfirmedError, UserIdsNotMatchingError, UsernameContainsIllegalCharacterError, UserNotFoundError } from '../errors/UserErrors';
 import { UserGroupNotFoundError } from '../errors/UserGroupErrors';
 import { CreateUser } from '../models/actions/create/CreateUser';
 import { UpdateUser } from '../models/actions/update/UpdateUser';
@@ -105,9 +105,11 @@ export class UserController {
 	@Authorized("USER:DELETE")
 	@ResponseSchema(ResponseUser)
 	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@ResponseSchema(UserDeletionNotConfirmedError, { statusCode: 406 })
 	@OnUndefined(204)
-	@OpenAPI({ description: 'Delete the user whose id you provided. <br> If there are any permissions directly granted to the user they will get deleted as well. <br> If no user with this id exists it will just return 204(no content).' })
+	@OpenAPI({ description: 'Delete the user whose id you provided. <br> You have to confirm your decision by providing the ?force=true query param. <br> If there are any permissions directly granted to the user they will get deleted as well. <br> If no user with this id exists it will just return 204(no content).' })
 	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
+		if (!force) { throw new UserDeletionNotConfirmedError; }
 		let user = await this.userRepository.findOne({ id: id });
 		if (!user) { return null; }
 		const responseUser = await this.userRepository.findOne({ id: id }, { relations: ['permissions', 'groups', 'groups.permissions'] });;
--- a/src/errors/AddressErrors.ts
+++ b/src/errors/AddressErrors.ts
@@ -1,24 +1,57 @@
 import { IsString } from 'class-validator';
-import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+import { BadRequestError } from 'routing-controllers';

 /**
- * Error to throw, when to provided address doesn't belong to the accepted types.
+ * Error to throw when an address's postal code fails validation.
 */
-export class AddressWrongTypeError extends NotAcceptableError {
+export class AddressPostalCodeInvalidError extends BadRequestError {
 	@IsString()
-	name = "AddressWrongTypeError"
+	name = "AddressPostalCodeInvalidError"

 	@IsString()
-	message = "The address must be an existing address's id. \n You provided a object of another type."
+	message = "The postal code you provided is invalid. \n Please check if your postal code follows the postal code validation guidelines."
 }

 /**
- * Error to throw, when a non-existent address get's loaded.
+ * Error to throw when an non-empty address's first line isn't set.
 */
-export class AddressNotFoundError extends NotFoundError {
+export class AddressFirstLineEmptyError extends BadRequestError {
 	@IsString()
-	name = "AddressNotFoundError"
+	name = "AddressFirstLineEmptyError"

 	@IsString()
-	message = "The address you provided couldn't be located in the system. \n Please check your request."
+	message = "You provided a empty first address line. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's postal code isn't set.
+ */
+export class AddressPostalCodeEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressPostalCodeEmptyError"
+
+	@IsString()
+	message = "You provided a empty postal code. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's city isn't set.
+ */
+export class AddressCityEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressCityEmptyError"
+
+	@IsString()
+	message = "You provided a empty city. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
+}
+
+/**
+ * Error to throw when an non-empty address's country isn't set.
+ */
+export class AddressCountryEmptyError extends BadRequestError {
+	@IsString()
+	name = "AddressCountryEmptyError"
+
+	@IsString()
+	message = "You provided a empty country. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
 }
--- a/src/errors/GroupContactErrors.ts
+++ b/src/errors/GroupContactErrors.ts
@@ -2,18 +2,7 @@ import { IsString } from 'class-validator';
 import { NotAcceptableError, NotFoundError } from 'routing-controllers';

 /**
- * Error to throw, when a provided groupContact doesn't belong to the accepted types.
- */
-export class GroupContactWrongTypeError extends NotAcceptableError {
-	@IsString()
-	name = "GroupContactWrongTypeError"
-
-	@IsString()
-	message = "The groupContact must be an existing groupContact's id. \n You provided a object of another type."
-}
-
-/**
- * Error to throw, when a non-existent groupContact get's loaded.
+ * Error to throw, when a non-existent contact get's requested.
 */
 export class GroupContactNotFoundError extends NotFoundError {
 	@IsString()
@@ -21,4 +10,16 @@ export class GroupContactNotFoundError extends NotFoundError {

 	@IsString()
 	message = "The groupContact you provided couldn't be located in the system. \n Please check your request."
-}
+}
+
+/**
+ * Error to throw when two contacts' ids don't match.
+ * Usually occurs when a user tries to change a contact's id.
+ */
+export class GroupContactIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "GroupContactIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a contact's id: This isn't allowed!"
+}
--- a/src/errors/RunnerErrors.ts
+++ b/src/errors/RunnerErrors.ts
@@ -32,7 +32,18 @@ export class RunnerGroupNeededError extends NotAcceptableError {
 	name = "RunnerGroupNeededError"

 	@IsString()
-	message = "Runner's need to be part of one group (team or organisation)! \n You provided neither."
+	message = "Runner's need to be part of one group (team or organization)! \n You provided neither."
+}
+
+/**
+ * Error to throw when a citizen runner has no mail-address.
+ */
+export class RunnerEmailNeededError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerEmailNeededError"
+
+	@IsString()
+	message = "Citizenrunners have to provide an email address for verification and contacting."
 }

 /**
--- a/src/errors/RunnerOrganisationErrors.ts
+++ b/src/errors/RunnerOrganisationErrors.ts
@@ -1,58 +0,0 @@
-import { IsString } from 'class-validator';
-import { NotAcceptableError, NotFoundError } from 'routing-controllers';
-
-/**
- * Error to throw when a runner organisation couldn't be found.
- */
-export class RunnerOrganisationNotFoundError extends NotFoundError {
-	@IsString()
-	name = "RunnerOrganisationNotFoundError"
-
-	@IsString()
-	message = "RunnerOrganisation not found!"
-}
-
-/**
- * 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 {
-	@IsString()
-	name = "RunnerOrganisationIdsNotMatchingError"
-
-	@IsString()
-	message = "The ids don't match! \n And if you wanted to change a runner organisation's id: This isn't allowed!"
-}
-
-/**
- * Error to throw when a organisation still has runners associated.
- */
-export class RunnerOrganisationHasRunnersError extends NotAcceptableError {
-	@IsString()
-	name = "RunnerOrganisationHasRunnersError"
-
-	@IsString()
-	message = "This organisation still has runners associated with it. \n If you want to delete this organisation with all it's runners and teams add `?force` to your query."
-}
-
-/**
- * Error to throw when a organisation still has teams associated.
- */
-export class RunnerOrganisationHasTeamsError extends NotAcceptableError {
-	@IsString()
-	name = "RunnerOrganisationHasTeamsError"
-
-	@IsString()
-	message = "This organisation still has teams associated with it. \n If you want to delete this organisation with all it's runners and teams add `?force` to your query."
-}
-
-/**
- * Error to throw, when a provided runnerOrganisation doesn't belong to the accepted types.
- */
-export class RunnerOrganisationWrongTypeError extends NotAcceptableError {
-	@IsString()
-	name = "RunnerOrganisationWrongTypeError"
-
-	@IsString()
-	message = "The runner organisation must be an existing organisation's id. \n You provided a object of another type."
-}
--- a/src/errors/RunnerOrganizationErrors.ts
+++ b/src/errors/RunnerOrganizationErrors.ts
@@ -0,0 +1,58 @@
+import { IsString } from 'class-validator';
+import { NotAcceptableError, NotFoundError } from 'routing-controllers';
+
+/**
+ * Error to throw when a runner organization couldn't be found.
+ */
+export class RunnerOrganizationNotFoundError extends NotFoundError {
+	@IsString()
+	name = "RunnerOrganizationNotFoundError"
+
+	@IsString()
+	message = "RunnerOrganization not found!"
+}
+
+/**
+ * Error to throw when two runner organization's ids don't match.
+ * Usually occurs when a user tries to change a runner organization's id.
+ */
+export class RunnerOrganizationIdsNotMatchingError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerOrganizationIdsNotMatchingError"
+
+	@IsString()
+	message = "The ids don't match! \n And if you wanted to change a runner organization's id: This isn't allowed!"
+}
+
+/**
+ * Error to throw when a organization still has runners associated.
+ */
+export class RunnerOrganizationHasRunnersError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerOrganizationHasRunnersError"
+
+	@IsString()
+	message = "This organization still has runners associated with it. \n If you want to delete this organization with all it's runners and teams add `?force` to your query."
+}
+
+/**
+ * Error to throw when a organization still has teams associated.
+ */
+export class RunnerOrganizationHasTeamsError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerOrganizationHasTeamsError"
+
+	@IsString()
+	message = "This organization still has teams associated with it. \n If you want to delete this organization with all it's runners and teams add `?force` to your query."
+}
+
+/**
+ * Error to throw, when a provided runnerOrganization doesn't belong to the accepted types.
+ */
+export class RunnerOrganizationWrongTypeError extends NotAcceptableError {
+	@IsString()
+	name = "RunnerOrganizationWrongTypeError"
+
+	@IsString()
+	message = "The runner organization must be an existing organization's id. \n You provided a object of another type."
+}
--- a/src/errors/RunnerTeamErrors.ts
+++ b/src/errors/RunnerTeamErrors.ts
@@ -43,5 +43,5 @@ export class RunnerTeamNeedsParentError extends NotAcceptableError {
 	name = "RunnerTeamNeedsParentError"

 	@IsString()
-	message = "You provided no runner organisation as this team's parent group."
+	message = "You provided no runner organization as this team's parent group."
 }
--- a/src/errors/UserErrors.ts
+++ b/src/errors/UserErrors.ts
@@ -59,4 +59,16 @@ export class UserIdsNotMatchingError extends NotAcceptableError {

 	@IsString()
 	message = "The ids don't match!! \n And if you wanted to change a user's id: This isn't allowed!"
+}
+
+/**
+ * Error to throw when two users' ids don't match.
+ * Usually occurs when a user tries to change a user's id.
+ */
+export class UserDeletionNotConfirmedError extends NotAcceptableError {
+	@IsString()
+	name = "UserDeletionNotConfirmedError"
+
+	@IsString()
+	message = "You are trying to delete a user! \n If you're sure about doing this: provide the ?force=true query param."
 }
--- a/src/jwtcreator.ts
+++ b/src/jwtcreator.ts
@@ -1,6 +1,7 @@
 import { IsBoolean, IsEmail, IsInt, IsNotEmpty, IsOptional, IsString, IsUUID } from 'class-validator';
 import * as jsonwebtoken from "jsonwebtoken";
 import { config } from './config';
+import { Runner } from './models/entities/Runner';
 import { User } from './models/entities/User';

 /**
@@ -34,6 +35,19 @@ export class JwtCreator {
        }, config.jwt_secret)
    }

+    /**
+     * Creates a new selfservice token for a given runner.
+     * @param runner Runner entity that the access token shall be created for.
+     * @param expiry_timestamp Timestamp for the token expiry. Will be set about 9999 years if none provided.
+     */
+    public static createSelfService(runner: Runner, expiry_timestamp?: number) {
+        if (!expiry_timestamp) { expiry_timestamp = Math.floor(Date.now() / 1000) + 36000 * 60 * 24 * 365 * 9999; }
+        return jsonwebtoken.sign({
+            id: runner.id,
+            exp: expiry_timestamp
+        }, config.jwt_secret)
+    }
+
    /**
     * Creates a new password reset token for a given user.
     * The token is valid for 15 minutes or 1 use - whatever comes first.
--- a/src/loaders/database.ts
+++ b/src/loaders/database.ts
@@ -1,6 +1,9 @@
 import { createConnection } from "typeorm";
 import { runSeeder } from 'typeorm-seeding';
-import { User } from '../models/entities/User';
+import { config } from '../config';
+import { ConfigFlag } from '../models/entities/ConfigFlags';
+import SeedPublicOrg from '../seeds/SeedPublicOrg';
+import SeedTestRunners from '../seeds/SeedTestRunners';
 import SeedUsers from '../seeds/SeedUsers';
 /**
 * Loader for the database that creates the database connection and initializes the database tabels.
@@ -9,8 +12,20 @@ import SeedUsers from '../seeds/SeedUsers';
 export default async () => {
    const connection = await createConnection();
    await connection.synchronize();
-    if (await connection.getRepository(User).count() === 0) {
+
+    //The data seeding part
+    if (!(await connection.getRepository(ConfigFlag).findOne({ option: "seeded:user", value: "true" }))) {
        await runSeeder(SeedUsers);
+        await connection.getRepository(ConfigFlag).save({ option: "seeded:user", value: "true" });
    }
+    if (!(await connection.getRepository(ConfigFlag).findOne({ option: "seeded:citizenorg", value: "true" }))) {
+        await runSeeder(SeedPublicOrg);
+        await connection.getRepository(ConfigFlag).save({ option: "seeded:citizenorg", value: "true" });
+    }
+    if (!(await connection.getRepository(ConfigFlag).findOne({ option: "seeded:testdata", value: "true" })) && config.seedTestData == true) {
+        await runSeeder(SeedTestRunners);
+        await connection.getRepository(ConfigFlag).save({ option: "seeded:testdata", value: "true" });
+    }
+
    return connection;
 };
--- a/src/middlewares/StatsAuth.ts
+++ b/src/middlewares/StatsAuth.ts
@@ -42,7 +42,7 @@ const StatsAuth = async (req: Request, res: Response, next: () => void) => {
        let user_authorized = false;
        try {
            let action = { request: req, response: res, context: null, next: next }
-            user_authorized = await authchecker(action, ["RUNNER:GET", "TEAM:GET", "ORGANISATION:GET"]);
+            user_authorized = await authchecker(action, ["RUNNER:GET", "TEAM:GET", "ORGANIZATION:GET"]);
        }
        finally {
            if (user_authorized == false) {
--- a/src/middlewares/UserChecker.ts
+++ b/src/middlewares/UserChecker.ts
@@ -0,0 +1,58 @@
+import cookie from "cookie";
+import * as jwt from "jsonwebtoken";
+import { Action } from 'routing-controllers';
+import { getConnectionManager } from 'typeorm';
+import { config } from '../config';
+import { IllegalJWTError, UserDisabledError, UserNonexistantOrRefreshtokenInvalidError } from '../errors/AuthError';
+import { JwtCreator, JwtUser } from '../jwtcreator';
+import { User } from '../models/entities/User';
+
+/**
+ * TODO:
+ */
+const UserChecker = async (action: Action) => {
+    let jwtPayload = undefined
+    try {
+        let provided_token = "" + action.request.headers["authorization"].replace("Bearer ", "");
+        jwtPayload = <any>jwt.verify(provided_token, config.jwt_secret);
+        jwtPayload = jwtPayload["userdetails"];
+    } catch (error) {
+        jwtPayload = await refresh(action);
+    }
+
+    const user = await getConnectionManager().get().getRepository(User).findOne({ id: jwtPayload["id"], refreshTokenCount: jwtPayload["refreshTokenCount"] })
+    if (!user) { throw new UserNonexistantOrRefreshtokenInvalidError() }
+    if (user.enabled == false) { throw new UserDisabledError(); }
+    return user;
+};
+
+/**
+ * Handles soft-refreshing of access-tokens.
+ * @param action Routing-Controllers action object that provides request and response objects among other stuff.
+ */
+const refresh = async (action: Action) => {
+    let refresh_token = undefined;
+    try {
+        refresh_token = cookie.parse(action.request.headers["cookie"])["lfk_backend__refresh_token"];
+    }
+    catch {
+        throw new IllegalJWTError();
+    }
+
+    let jwtPayload = undefined;
+    try {
+        jwtPayload = <any>jwt.verify(refresh_token, config.jwt_secret);
+    } catch (error) {
+        throw new IllegalJWTError();
+    }
+
+    const user = await getConnectionManager().get().getRepository(User).findOne({ id: jwtPayload["id"], refreshTokenCount: jwtPayload["refreshTokenCount"] }, { relations: ['permissions', 'groups', 'groups.permissions'] })
+    if (!user) { throw new UserNonexistantOrRefreshtokenInvalidError() }
+    if (user.enabled == false) { throw new UserDisabledError(); }
+
+    let newAccess = JwtCreator.createAccess(user);
+    action.response.header("authorization", "Bearer " + newAccess);
+
+    return await new JwtUser(user);
+}
+export default UserChecker;
--- a/src/models/actions/ImportRunner.ts
+++ b/src/models/actions/ImportRunner.ts
@@ -1,9 +1,9 @@
 import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { RunnerGroupNeededError } from '../../errors/RunnerErrors';
-import { RunnerOrganisationNotFoundError } from '../../errors/RunnerOrganisationErrors';
+import { RunnerOrganizationNotFoundError } from '../../errors/RunnerOrganizationErrors';
 import { RunnerGroup } from '../entities/RunnerGroup';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
+import { RunnerOrganization } from '../entities/RunnerOrganization';
 import { RunnerTeam } from '../entities/RunnerTeam';
 import { CreateRunner } from './create/CreateRunner';

@@ -78,9 +78,9 @@ export class ImportRunner {
        let team = await getConnectionManager().get().getRepository(RunnerTeam).findOne({ id: groupID });
        if (team) { return team; }

-        let org = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: groupID });
+        let org = await getConnectionManager().get().getRepository(RunnerOrganization).findOne({ id: groupID });
        if (!org) {
-            throw new RunnerOrganisationNotFoundError();
+            throw new RunnerOrganizationNotFoundError();
        }
        if (this.team === undefined) { return org; }

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

@@ -26,10 +27,10 @@ export class CreateDonor extends CreateParticipant {
        newDonor.lastname = this.lastname;
        newDonor.phone = this.phone;
        newDonor.email = this.email;
-        newDonor.address = await this.getAddress();
        newDonor.receiptNeeded = this.receiptNeeded;
-
-        if (this.receiptNeeded == true && this.address == null) {
+        newDonor.address = this.address;
+        Address.validate(newDonor.address);
+        if (this.receiptNeeded == true && Address.isValidAddress(newDonor.address) == false) {
            throw new DonorReceiptAddressNeededError()
        }

--- a/src/models/actions/create/CreateGroupContact.ts
+++ b/src/models/actions/create/CreateGroupContact.ts
@@ -1,12 +1,13 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { config } from '../../../config';
-import { AddressNotFoundError } from '../../../errors/AddressErrors';
+import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
 import { Address } from '../../entities/Address';
 import { GroupContact } from '../../entities/GroupContact';
+import { RunnerGroup } from '../../entities/RunnerGroup';

 /**
- * This classed is used to create a new Group entity from a json body (post request).
+ * This classed is used to create a new GroupContact entity from a json body (post request).
 */
 export class CreateGroupContact {
    /**
@@ -31,11 +32,11 @@ export class CreateGroupContact {
    lastname: string;

    /**
-     * The new contact's address's id.
+     * The new contact's address.
     */
-    @IsInt()
    @IsOptional()
-    address?: number;
+    @IsObject()
+    address?: Address;

    /**
     * The contact's phone number.
@@ -46,33 +47,51 @@ export class CreateGroupContact {
    phone?: string;

    /**
-     * The contact's email address.
+     * The new contact's email address.
     */
    @IsOptional()
    @IsEmail()
    email?: string;

    /**
-     * Gets the new contact's address by it's id.
+     * The new contacts's groups' ids.
+     * You can provide either one groupId or an array of groupIDs.
     */
-    public async getAddress(): Promise<Address> {
-        if (!this.address) { return null; }
-        let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-        if (!address) { throw new AddressNotFoundError; }
-        return address;
+    @IsOptional()
+    groups?: number[] | number
+
+
+    /**
+     * Get's all groups for this contact by their id's;
+     */
+    public async getGroups(): Promise<RunnerGroup[]> {
+        if (!this.groups) { return null; }
+        let groups = new Array<RunnerGroup>();
+        if (!Array.isArray(this.groups)) {
+            this.groups = [this.groups]
+        }
+        for (let group of this.groups) {
+            let found = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: group });
+            if (!found) { throw new RunnerGroupNotFoundError(); }
+            groups.push(found);
+        }
+        return groups;
    }

    /**
-     * Creates a new Address entity from this.
+     * Creates a new GroupContact entity from this.
     */
    public async toEntity(): Promise<GroupContact> {
-        let contact: GroupContact = new GroupContact();
-        contact.firstname = this.firstname;
-        contact.middlename = this.middlename;
-        contact.lastname = this.lastname;
-        contact.email = this.email;
-        contact.phone = this.phone;
-        contact.address = await this.getAddress();
-        return null;
+        let newContact: GroupContact = new GroupContact();
+        newContact.firstname = this.firstname;
+        newContact.middlename = this.middlename;
+        newContact.lastname = this.lastname;
+        newContact.email = this.email;
+        newContact.phone = this.phone;
+        newContact.address = this.address;
+        Address.validate(newContact.address);
+        newContact.groups = await this.getGroups();
+
+        return newContact;
    }
 }
--- a/src/models/actions/create/CreateParticipant.ts
+++ b/src/models/actions/create/CreateParticipant.ts
@@ -1,7 +1,5 @@
-import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
-import { getConnectionManager } from 'typeorm';
+import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
 import { config } from '../../../config';
-import { AddressNotFoundError } from '../../../errors/AddressErrors';
 import { Address } from '../../entities/Address';

 /**
@@ -47,19 +45,9 @@ export abstract class CreateParticipant {
    email?: string;

    /**
-     * The new participant's address's id.
+     * The new participant's address.
     */
-    @IsInt()
    @IsOptional()
-    address?: number;
-
-    /**
-     * Gets the new participant's address by it's id.
-     */
-    public async getAddress(): Promise<Address> {
-        if (!this.address) { return null; }
-        let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-        if (!address) { throw new AddressNotFoundError; }
-        return address;
-    }
+    @IsObject()
+    address?: Address;
 }
--- a/src/models/actions/create/CreateRunner.ts
+++ b/src/models/actions/create/CreateRunner.ts
@@ -1,8 +1,9 @@
 import { IsInt } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
 import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
-import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerOrganizationWrongTypeError } from '../../../errors/RunnerOrganizationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
+import { Address } from '../../entities/Address';
 import { Runner } from '../../entities/Runner';
 import { RunnerGroup } from '../../entities/RunnerGroup';
 import { CreateParticipant } from './CreateParticipant';
@@ -30,7 +31,8 @@ export class CreateRunner extends CreateParticipant {
        newRunner.phone = this.phone;
        newRunner.email = this.email;
        newRunner.group = await this.getGroup();
-        newRunner.address = await this.getAddress();
+        newRunner.address = this.address;
+        Address.validate(newRunner.address);

        return newRunner;
    }
@@ -48,6 +50,6 @@ export class CreateRunner extends CreateParticipant {
            return group;
        }

-        throw new RunnerOrganisationWrongTypeError;
+        throw new RunnerOrganizationWrongTypeError;
    }
 }
--- a/src/models/actions/create/CreateRunnerOrganisation.ts
+++ b/src/models/actions/create/CreateRunnerOrganisation.ts
@@ -1,41 +0,0 @@
-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';
-
-/**
- * This classed is used to create a new RunnerOrganisation entity from a json body (post request).
- */
-export class CreateRunnerOrganisation extends CreateRunnerGroup {
-    /**
-     * The new organisation's address's id.
-     */
-    @IsInt()
-    @IsOptional()
-    address?: number;
-
-    /**
-     * Gets the org's address by it's id.
-     */
-    public async getAddress(): Promise<Address> {
-        if (!this.address) { return null; }
-        let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-        if (!address) { throw new AddressNotFoundError; }
-        return address;
-    }
-
-    /**
-     * Creates a new RunnerOrganisation entity from this.
-     */
-    public async toEntity(): Promise<RunnerOrganisation> {
-        let newRunnerOrganisation: RunnerOrganisation = new RunnerOrganisation();
-
-        newRunnerOrganisation.name = this.name;
-        newRunnerOrganisation.contact = await this.getContact();
-        newRunnerOrganisation.address = await this.getAddress();
-
-        return newRunnerOrganisation;
-    }
-}
--- a/src/models/actions/create/CreateRunnerOrganization.ts
+++ b/src/models/actions/create/CreateRunnerOrganization.ts
@@ -0,0 +1,43 @@
+import { IsBoolean, IsObject, IsOptional } from 'class-validator';
+import * as uuid from 'uuid';
+import { Address } from '../../entities/Address';
+import { RunnerOrganization } from '../../entities/RunnerOrganization';
+import { CreateRunnerGroup } from './CreateRunnerGroup';
+
+
+/**
+ * This classed is used to create a new RunnerOrganization entity from a json body (post request).
+ */
+export class CreateRunnerOrganization extends CreateRunnerGroup {
+    /**
+     * The new organization's address.
+     */
+    @IsOptional()
+    @IsObject()
+    address?: Address;
+
+    /**
+     * Is registration enabled for the new organization?
+     */
+    @IsOptional()
+    @IsBoolean()
+    registrationEnabled?: boolean = false;
+
+    /**
+     * Creates a new RunnerOrganization entity from this.
+     */
+    public async toEntity(): Promise<RunnerOrganization> {
+        let newRunnerOrganization: RunnerOrganization = new RunnerOrganization();
+
+        newRunnerOrganization.name = this.name;
+        newRunnerOrganization.contact = await this.getContact();
+        newRunnerOrganization.address = this.address;
+        Address.validate(newRunnerOrganization.address);
+
+        if (this.registrationEnabled) {
+            newRunnerOrganization.key = uuid.v4().toUpperCase();
+        }
+
+        return newRunnerOrganization;
+    }
+}
--- a/src/models/actions/create/CreateRunnerTeam.ts
+++ b/src/models/actions/create/CreateRunnerTeam.ts
@@ -1,8 +1,8 @@
 import { IsInt, IsNotEmpty } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerOrganizationNotFoundError } from '../../../errors/RunnerOrganizationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
-import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
+import { RunnerOrganization } from '../../entities/RunnerOrganization';
 import { RunnerTeam } from '../../entities/RunnerTeam';
 import { CreateRunnerGroup } from './CreateRunnerGroup';

@@ -21,12 +21,12 @@ export class CreateRunnerTeam extends CreateRunnerGroup {
    /**
     * Gets the new team's parent org based on it's id.
     */
-    public async getParent(): Promise<RunnerOrganisation> {
+    public async getParent(): Promise<RunnerOrganization> {
        if (this.parentGroup === undefined || this.parentGroup === null) {
            throw new RunnerTeamNeedsParentError();
        }
-        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup });
-        if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
+        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganization).findOne({ id: this.parentGroup });
+        if (!parentGroup) { throw new RunnerOrganizationNotFoundError();; }
        return parentGroup;
    }

--- a/src/models/actions/create/CreateSelfServiceCitizenRunner.ts
+++ b/src/models/actions/create/CreateSelfServiceCitizenRunner.ts
@@ -0,0 +1,52 @@
+import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerEmailNeededError } from '../../../errors/RunnerErrors';
+import { Address } from '../../entities/Address';
+import { Runner } from '../../entities/Runner';
+import { RunnerOrganization } from '../../entities/RunnerOrganization';
+import { CreateParticipant } from './CreateParticipant';
+
+/**
+ * This classed is used to create a new Runner entity from a json body (post request).
+ */
+export class CreateSelfServiceCitizenRunner extends CreateParticipant {
+
+    /**
+     * The new runners's e-mail address.
+     * Must be provided for email-verification to work.
+     */
+    @IsString()
+    @IsNotEmpty()
+    @IsEmail()
+    email: string;
+
+    /**
+     * Creates a new Runner entity from this.
+     */
+    public async toEntity(): Promise<Runner> {
+        let newRunner: Runner = new Runner();
+
+        newRunner.firstname = this.firstname;
+        newRunner.middlename = this.middlename;
+        newRunner.lastname = this.lastname;
+        newRunner.phone = this.phone;
+        newRunner.email = this.email;
+
+        if (!newRunner.email) {
+            throw new RunnerEmailNeededError();
+        }
+
+        newRunner.group = await this.getGroup();
+        newRunner.address = this.address;
+        Address.validate(newRunner.address);
+
+        return newRunner;
+    }
+
+    /**
+     * Gets the new runner's group by it's id.
+     */
+    public async getGroup(): Promise<RunnerOrganization> {
+        return await getConnection().getRepository(RunnerOrganization).findOne({ id: 1 });
+    }
+}
--- a/src/models/actions/create/CreateSelfServiceRunner.ts
+++ b/src/models/actions/create/CreateSelfServiceRunner.ts
@@ -0,0 +1,55 @@
+import { IsInt, IsOptional } from 'class-validator';
+import { getConnection } from 'typeorm';
+import { RunnerTeamNotFoundError } from '../../../errors/RunnerTeamErrors';
+import { Address } from '../../entities/Address';
+import { Runner } from '../../entities/Runner';
+import { RunnerGroup } from '../../entities/RunnerGroup';
+import { RunnerTeam } from '../../entities/RunnerTeam';
+import { CreateParticipant } from './CreateParticipant';
+
+/**
+ * This classed is used to create a new Runner entity from a json body (post request).
+ */
+export class CreateSelfServiceRunner extends CreateParticipant {
+
+    /**
+     * The new runner's team's id.
+     * The team has to be a part of the runner's org.
+     * The team property may get ignored.
+     * If no team get's provided the runner's group will be their org.
+     */
+    @IsInt()
+    @IsOptional()
+    team?: number;
+
+    /**
+     * Creates a new Runner entity from this.
+     */
+    public async toEntity(group: RunnerGroup): Promise<Runner> {
+        let newRunner: Runner = new Runner();
+
+        newRunner.firstname = this.firstname;
+        newRunner.middlename = this.middlename;
+        newRunner.lastname = this.lastname;
+        newRunner.phone = this.phone;
+        newRunner.email = this.email;
+        newRunner.group = await this.getGroup(group);
+        newRunner.address = this.address;
+        Address.validate(newRunner.address);
+
+        return newRunner;
+    }
+
+    /**
+     * Gets the new runner's group by it's id.
+     */
+    public async getGroup(group: RunnerGroup): Promise<RunnerGroup> {
+        if (!this.team) {
+            return group;
+        }
+        const team = await getConnection().getRepository(RunnerTeam).findOne({ id: this.team }, { relations: ["parentGroup"] });
+        if (!team) { throw new RunnerTeamNotFoundError(); }
+        if (team.parentGroup.id != group.id) { throw new RunnerTeamNotFoundError(); }
+        return team;
+    }
+}
--- a/src/models/actions/update/UpdateDonor.ts
+++ b/src/models/actions/update/UpdateDonor.ts
@@ -1,5 +1,6 @@
 import { IsBoolean, IsInt, IsOptional } from 'class-validator';
 import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
+import { Address } from '../../entities/Address';
 import { Donor } from '../../entities/Donor';
 import { CreateParticipant } from '../create/CreateParticipant';

@@ -33,9 +34,10 @@ export class UpdateDonor extends CreateParticipant {
        donor.phone = this.phone;
        donor.email = this.email;
        donor.receiptNeeded = this.receiptNeeded;
-        donor.address = await this.getAddress();
-
-        if (this.receiptNeeded == true && this.address == null) {
+        if (!this.address) { donor.address.reset(); }
+        else { donor.address = this.address; }
+        Address.validate(donor.address);
+        if (this.receiptNeeded == true && Address.isValidAddress(donor.address) == false) {
            throw new DonorReceiptAddressNeededError()
        }

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

        return runner;
    }
--- a/src/models/actions/update/UpdateRunnerOrganisation.ts
+++ b/src/models/actions/update/UpdateRunnerOrganisation.ts
@@ -1,48 +0,0 @@
-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 '../create/CreateRunnerGroup';
-
-/**
- * This class is used to update a RunnerOrganisation entity (via put request).
- */
-export class UpdateRunnerOrganisation extends CreateRunnerGroup {
-
-    /**
-     * The updated orgs'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 organisation's address's id.
-     */
-    @IsInt()
-    @IsOptional()
-    address?: number;
-
-    /**
-     * Loads the organisation's address based on it's id.
-     */
-    public async getAddress(): Promise<Address> {
-        if (!this.address) { return null; }
-        let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
-        if (!address) { throw new AddressNotFoundError; }
-        return address;
-    }
-
-    /**
-     * Updates a provided RunnerOrganisation entity based on this.
-     */
-    public async update(organisation: RunnerOrganisation): Promise<RunnerOrganisation> {
-
-        organisation.name = this.name;
-        organisation.contact = await this.getContact();
-        organisation.address = await this.getAddress();
-
-        return organisation;
-    }
-}
--- a/src/models/actions/update/UpdateRunnerOrganization.ts
+++ b/src/models/actions/update/UpdateRunnerOrganization.ts
@@ -0,0 +1,53 @@
+import { IsBoolean, IsInt, IsObject, IsOptional } from 'class-validator';
+import * as uuid from 'uuid';
+import { Address } from '../../entities/Address';
+import { RunnerOrganization } from '../../entities/RunnerOrganization';
+import { CreateRunnerGroup } from '../create/CreateRunnerGroup';
+
+/**
+ * This class is used to update a RunnerOrganization entity (via put request).
+ */
+export class UpdateRunnerOrganization extends CreateRunnerGroup {
+
+    /**
+     * The updated orgs'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 organization's address.
+     */
+    @IsOptional()
+    @IsObject()
+    address?: Address;
+
+    /**
+     * Is registration enabled for the updated organization?
+     */
+    @IsOptional()
+    @IsBoolean()
+    registrationEnabled?: boolean = false;
+
+    /**
+     * Updates a provided RunnerOrganization entity based on this.
+     */
+    public async update(organization: RunnerOrganization): Promise<RunnerOrganization> {
+
+        organization.name = this.name;
+        organization.contact = await this.getContact();
+        if (!this.address) { organization.address.reset(); }
+        else { organization.address = this.address; }
+        Address.validate(organization.address);
+
+        if (this.registrationEnabled && !organization.key) {
+            organization.key = uuid.v4().toUpperCase();
+        }
+        else {
+            organization.key = null;
+        }
+
+        return organization;
+    }
+}
--- a/src/models/actions/update/UpdateRunnerTeam.ts
+++ b/src/models/actions/update/UpdateRunnerTeam.ts
@@ -1,8 +1,8 @@
 import { IsInt, IsPositive } from 'class-validator';
 import { getConnectionManager } from 'typeorm';
-import { RunnerOrganisationNotFoundError } from '../../../errors/RunnerOrganisationErrors';
+import { RunnerOrganizationNotFoundError } from '../../../errors/RunnerOrganizationErrors';
 import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
-import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
+import { RunnerOrganization } from '../../entities/RunnerOrganization';
 import { RunnerTeam } from '../../entities/RunnerTeam';
 import { CreateRunnerGroup } from '../create/CreateRunnerGroup';

@@ -28,12 +28,12 @@ export class UpdateRunnerTeam extends CreateRunnerGroup {
    /**
     * Loads the updated teams's parentGroup based on it's id.
     */
-    public async getParent(): Promise<RunnerOrganisation> {
+    public async getParent(): Promise<RunnerOrganization> {
        if (this.parentGroup === undefined || this.parentGroup === null) {
            throw new RunnerTeamNeedsParentError();
        }
-        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganisation).findOne({ id: this.parentGroup });
-        if (!parentGroup) { throw new RunnerOrganisationNotFoundError();; }
+        let parentGroup = await getConnectionManager().get().getRepository(RunnerOrganization).findOne({ id: this.parentGroup });
+        if (!parentGroup) { throw new RunnerOrganizationNotFoundError();; }
        return parentGroup;
    }

--- a/src/models/actions/update/UpdateUser.ts
+++ b/src/models/actions/update/UpdateUser.ts
@@ -76,6 +76,7 @@ export class UpdateUser {
     * Should the user be enabled?
     */
    @IsBoolean()
+    @IsOptional()
    enabled: boolean = true;

    /**
--- a/src/models/entities/Address.ts
+++ b/src/models/entities/Address.ts
@@ -1,44 +1,24 @@
 import {
-  IsInt,
-  IsNotEmpty,
-  IsOptional,
  IsPostalCode,
  IsString
 } from "class-validator";
-import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { Column } from "typeorm";
+import ValidatorJS from 'validator';
 import { config } from '../../config';
-import { IAddressUser } from './IAddressUser';
+import { AddressCityEmptyError, AddressCountryEmptyError, AddressFirstLineEmptyError, AddressPostalCodeEmptyError, AddressPostalCodeInvalidError } from '../../errors/AddressErrors';

 /**
- * Defines the Address entity.
+ * Defines the Address class.
 * Implemented this way to prevent any formatting differences.
 */
-@Entity()
 export class Address {
-  /**
-   * Autogenerated unique id (primary key).
-   */
-  @PrimaryGeneratedColumn()
-  @IsInt()
-  id: number;
-
-  /**
-   * The address's description.
-   * Optional and mostly for UX.
-   */
-  @Column({ nullable: true })
-  @IsString()
-  @IsOptional()
-  description?: string;
-
  /**
   * The address's first line.
   * Containing the street and house number.
   */
-  @Column()
+  @Column({ nullable: true })
  @IsString()
-  @IsNotEmpty()
-  address1: string;
+  address1?: string;

  /**
   * The address's second line.
@@ -46,45 +26,61 @@ export class Address {
   */
  @Column({ nullable: true })
  @IsString()
-  @IsOptional()
  address2?: string;

  /**
   * The address's postal code.
   * This will get checked against the postal code syntax for the configured country.
   */
-  @Column()
+  @Column({ nullable: true })
  @IsString()
-  @IsNotEmpty()
  @IsPostalCode(config.postalcode_validation_countrycode)
  postalcode: string;

  /**
   * The address's city.
   */
-  @Column()
+  @Column({ nullable: true })
  @IsString()
-  @IsNotEmpty()
  city: string;

  /**
   * The address's country.
   */
-  @Column()
+  @Column({ nullable: true })
  @IsString()
-  @IsNotEmpty()
  country: string;

-  /**
-   * Used to link the address to participants.
-   */
-  @OneToMany(() => IAddressUser, addressUser => addressUser.address, { nullable: true })
-  addressUsers: IAddressUser[];
+  public reset() {
+    this.address1 = null;
+    this.address2 = null;
+    this.city = null;
+    this.country = null;
+    this.postalcode = null;
+  }

  /**
-   * Turns this entity into it's response class.
+   * Checks if this is a valid address
   */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public static isValidAddress(address: Address): Boolean {
+    if (address == null) { return false; }
+    if (address.address1 == null || address.city == null || address.country == null || address.postalcode == null) { return false; }
+    if (ValidatorJS.isPostalCode(address.postalcode, config.postalcode_validation_countrycode) == false) { return false; }
+    return true;
+  }
+
+  /**
+   * This function validates addresses.
+   * This is a workaround for non-existant class validation for embedded entities.
+   * @param address The address that shall get validated.
+   */
+  public static validate(address: Address) {
+    if (address == null) { return; }
+    if (address.address1 == null && address.city == null && address.country == null && address.postalcode == null) { return; }
+    if (address.address1 == null) { throw new AddressFirstLineEmptyError(); }
+    if (address.postalcode == null) { throw new AddressPostalCodeEmptyError(); }
+    if (address.city == null) { throw new AddressCityEmptyError(); }
+    if (address.country == null) { throw new AddressCountryEmptyError(); }
+    if (ValidatorJS.isPostalCode(address.postalcode.toString(), config.postalcode_validation_countrycode) == false) { throw new AddressPostalCodeInvalidError(); }
  }
 }
--- a/src/models/entities/ConfigFlags.ts
+++ b/src/models/entities/ConfigFlags.ts
@@ -0,0 +1,27 @@
+import {
+    IsNotEmpty,
+    IsString
+} from "class-validator";
+import { Column, Entity, PrimaryColumn } from "typeorm";
+
+/**
+ * Defines the ConfigFlag entity.
+ * This entity can be used to set some flags on db init.
+*/
+@Entity()
+export class ConfigFlag {
+    /**
+     * The flag's name (primary).
+     */
+    @PrimaryColumn()
+    @IsString()
+    option: string;
+
+    /**
+     * The flag's value.
+     */
+    @Column()
+    @IsString()
+    @IsNotEmpty()
+    value: string;
+}
--- a/src/models/entities/GroupContact.ts
+++ b/src/models/entities/GroupContact.ts
@@ -7,10 +7,10 @@ import {

  IsString
 } from "class-validator";
-import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
 import { config } from '../../config';
+import { ResponseGroupContact } from '../responses/ResponseGroupContact';
 import { Address } from "./Address";
-import { IAddressUser } from './IAddressUser';
 import { RunnerGroup } from "./RunnerGroup";

 /**
@@ -18,7 +18,7 @@ import { RunnerGroup } from "./RunnerGroup";
 * Mainly it's own class to reduce duplicate code and enable contact's to be associated with multiple groups.
 */
@Entity()
-export class GroupContact implements IAddressUser {
+export class GroupContact {
  /**
   * Autogenerated unique id (primary key).
   */
@@ -54,8 +54,7 @@ export class GroupContact implements IAddressUser {
   * The contact's address.
   * This is a address object to prevent any formatting differences.
   */
-  @IsOptional()
-  @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
+  @Column(type => Address)
  address?: Address;

  /**
@@ -85,7 +84,7 @@ export class GroupContact implements IAddressUser {
  /**
   * Turns this entity into it's response class.
   */
-  public toResponse() {
-    return new Error("NotImplemented");
+  public toResponse(): ResponseGroupContact {
+    return new ResponseGroupContact(this);
  }
 }
--- a/src/models/entities/IAddressUser.ts
+++ b/src/models/entities/IAddressUser.ts
@@ -1,20 +0,0 @@
-import { Entity, ManyToOne, PrimaryColumn } from 'typeorm';
-import { Address } from './Address';
-
-/**
- * The interface(tm) all entities using addresses have to implement.
- * This is a abstract class, because apparently typeorm can't really work with interfaces :/
- */
-@Entity()
-export abstract class IAddressUser {
-    @PrimaryColumn()
-    id: number;
-
-    @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
-    address?: Address
-
-    /**
-   * Turns this entity into it's response class.
-   */
-    public abstract toResponse();
-}
--- a/src/models/entities/Participant.ts
+++ b/src/models/entities/Participant.ts
@@ -7,11 +7,10 @@ import {

  IsString
 } from "class-validator";
-import { Column, Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
+import { Column, Entity, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
 import { config } from '../../config';
 import { ResponseParticipant } from '../responses/ResponseParticipant';
 import { Address } from "./Address";
-import { IAddressUser } from './IAddressUser';

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

  /**
--- a/src/models/entities/Runner.ts
+++ b/src/models/entities/Runner.ts
@@ -16,7 +16,7 @@ import { Scan } from "./Scan";
 export class Runner extends Participant {
  /**
   * The runner's associated group.
-   * Can be a runner team or organisation.
+   * Can be a runner team or organization.
   */
  @IsNotEmpty()
  @ManyToOne(() => RunnerGroup, group => group.runners)
@@ -65,7 +65,7 @@ export class Runner extends Participant {
  */
  @IsInt()
  public get distanceDonationAmount(): number {
-    return this.distanceDonations.reduce((sum, current) => sum + current.amountPerDistance, 0) * this.distance;
+    return this.distanceDonations.reduce((sum, current) => sum + current.amount, 0);
  }

  /**
--- a/src/models/entities/RunnerOrganization.ts
+++ b/src/models/entities/RunnerOrganization.ts
@@ -1,35 +1,44 @@
-import { IsInt, IsOptional } from "class-validator";
-import { ChildEntity, ManyToOne, OneToMany } from "typeorm";
-import { ResponseRunnerOrganisation } from '../responses/ResponseRunnerOrganisation';
+import { IsInt, IsOptional, IsString } from "class-validator";
+import { ChildEntity, Column, OneToMany } from "typeorm";
+import { ResponseRunnerOrganization } from '../responses/ResponseRunnerOrganization';
 import { Address } from './Address';
-import { IAddressUser } from './IAddressUser';
 import { Runner } from './Runner';
 import { RunnerGroup } from "./RunnerGroup";
 import { RunnerTeam } from "./RunnerTeam";

 /**
- * Defines the RunnerOrganisation entity.
+ * Defines the RunnerOrganization entity.
 * This usually is a school, club or company.
 */
@ChildEntity()
-export class RunnerOrganisation extends RunnerGroup implements IAddressUser {
+export class RunnerOrganization extends RunnerGroup {

  /**
-   * The organisations's address.
+   * The organizations's address.
   */
  @IsOptional()
-  @ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
+  @Column(type => Address)
  address?: Address;

  /**
-   * The organisation's teams.
-   * Used to link teams to a organisation.
+   * The organization's teams.
+   * Used to link teams to a organization.
   */
  @OneToMany(() => RunnerTeam, team => team.parentGroup, { nullable: true })
  teams: RunnerTeam[];

  /**
-   * Returns all runners associated with this organisation (directly or indirectly via teams).
+   * The organization's api key for self-service registration.
+   * The api key can be used for the /runners/register/:token endpoint.
+   * Is has to be base64 encoded if used via the api (to keep url-safety).
+   */
+  @Column({ nullable: true, unique: true })
+  @IsString()
+  @IsOptional()
+  key?: string;
+
+  /**
+   * Returns all runners associated with this organization (directly or indirectly via teams).
   */
  public get allRunners(): Runner[] {
    let returnRunners: Runner[] = new Array<Runner>();
@@ -59,7 +68,7 @@ export class RunnerOrganisation extends RunnerGroup implements IAddressUser {
  /**
   * Turns this entity into it's response class.
   */
-  public toResponse(): ResponseRunnerOrganisation {
-    return new ResponseRunnerOrganisation(this);
+  public toResponse(): ResponseRunnerOrganization {
+    return new ResponseRunnerOrganization(this);
  }
 }
--- a/src/models/entities/RunnerTeam.ts
+++ b/src/models/entities/RunnerTeam.ts
@@ -2,7 +2,7 @@ import { IsNotEmpty } from "class-validator";
 import { ChildEntity, ManyToOne } from "typeorm";
 import { ResponseRunnerTeam } from '../responses/ResponseRunnerTeam';
 import { RunnerGroup } from "./RunnerGroup";
-import { RunnerOrganisation } from "./RunnerOrganisation";
+import { RunnerOrganization } from "./RunnerOrganization";

 /**
 * Defines the RunnerTeam entity.
@@ -13,11 +13,11 @@ export class RunnerTeam extends RunnerGroup {

  /**
   * The team's parent group.
-   * Every team has to be part of a runnerOrganisation - this get's checked on creation and update.
+   * Every team has to be part of a runnerOrganization - this get's checked on creation and update.
   */
  @IsNotEmpty()
-  @ManyToOne(() => RunnerOrganisation, org => org.teams, { nullable: true })
-  parentGroup?: RunnerOrganisation;
+  @ManyToOne(() => RunnerOrganization, org => org.teams, { nullable: true })
+  parentGroup?: RunnerOrganization;

  /**
   * Turns this entity into it's response class.
--- a/src/models/entities/User.ts
+++ b/src/models/entities/User.ts
@@ -138,8 +138,10 @@ export class User extends Principal {

    if (!this.groups) { return returnPermissions; }
    for (let group of this.groups) {
-      for (let permission of group.permissions) {
-        returnPermissions.push(permission);
+      if (group.permissions) {
+        for (let permission of group.permissions) {
+          returnPermissions.push(permission);
+        }
      }
    }
    return returnPermissions;
@@ -159,8 +161,10 @@ export class User extends Principal {

    if (!this.groups) { return returnPermissions; }
    for (let group of this.groups) {
-      for (let permission of group.permissions) {
-        returnPermissions.push(permission.toString());
+      if (group.permissions) {
+        for (let permission of group.permissions) {
+          returnPermissions.push(permission.toString());
+        }
      }
    }
    return Array.from(new Set(returnPermissions));
--- a/src/models/entities/UserGroup.ts
+++ b/src/models/entities/UserGroup.ts
@@ -1,40 +1,40 @@
-import {
-  IsNotEmpty,
-  IsOptional,
-  IsString
-} from "class-validator";
-import { ChildEntity, Column } from "typeorm";
-import { ResponsePrincipal } from '../responses/ResponsePrincipal';
-import { ResponseUserGroup } from '../responses/ResponseUserGroup';
-import { Principal } from './Principal';
-
-/**
- * Defines the UserGroup entity.
- * This entity describes a group of users with a set of permissions.
-*/
-@ChildEntity()
-export class UserGroup extends Principal {
-
-  /**
-   * The group's name
-   */
-  @Column()
-  @IsNotEmpty()
-  @IsString()
-  name: string;
-
-  /**
-   * The group's description
-   */
-  @Column({ nullable: true })
-  @IsOptional()
-  @IsString()
-  description?: string;
-
-  /**
-   * Turns this entity into it's response class.
-   */
-  public toResponse(): ResponsePrincipal {
-    return new ResponseUserGroup(this);
-  }
+import {
+  IsNotEmpty,
+  IsOptional,
+  IsString
+} from "class-validator";
+import { ChildEntity, Column } from "typeorm";
+import { ResponsePrincipal } from '../responses/ResponsePrincipal';
+import { ResponseUserGroup } from '../responses/ResponseUserGroup';
+import { Principal } from './Principal';
+
+/**
+ * Defines the UserGroup entity.
+ * This entity describes a group of users with a set of permissions.
+*/
+@ChildEntity()
+export class UserGroup extends Principal {
+
+  /**
+   * The group's name
+   */
+  @Column()
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  /**
+   * The group's description
+   */
+  @Column({ nullable: true })
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  /**
+   * Turns this entity into it's response class.
+   */
+  public toResponse(): ResponsePrincipal {
+    return new ResponseUserGroup(this);
+  }
 }
--- a/src/models/enums/PermissionTargets.ts
+++ b/src/models/enums/PermissionTargets.ts
@@ -3,7 +3,7 @@
 */
 export enum PermissionTarget {
    RUNNER = 'RUNNER',
-    ORGANISATION = 'ORGANISATION',
+    ORGANIZATION = 'ORGANIZATION',
    TEAM = 'TEAM',
    TRACK = 'TRACK',
    USER = 'USER',
@@ -14,5 +14,6 @@ export enum PermissionTarget {
    SCAN = 'SCAN',
    STATION = 'STATION',
    CARD = 'CARD',
-    DONATION = 'DONATION'
+    DONATION = 'DONATION',
+    CONTACT = 'CONTACT'
 }
--- a/src/models/responses/ResponseGroupContact.ts
+++ b/src/models/responses/ResponseGroupContact.ts
@@ -0,0 +1,76 @@
+import { IsInt, IsObject, IsString } from "class-validator";
+import { Address } from '../entities/Address';
+import { GroupContact } from '../entities/GroupContact';
+import { ResponseRunnerGroup } from './ResponseRunnerGroup';
+
+/**
+ * Defines the group contact response.
+*/
+export class ResponseGroupContact {
+    /**
+     * The contact's id.
+     */
+    @IsInt()
+    id: number;
+
+    /**
+     * The contact's first name.
+     */
+    @IsString()
+    firstname: string;
+
+    /**
+     * The contact's middle name.
+     */
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The contact's last name.
+     */
+    @IsString()
+    lastname: string;
+
+    /**
+     * The contact's phone number.
+     */
+    @IsString()
+    phone?: string;
+
+    /**
+     * The contact's e-mail address.
+     */
+    @IsString()
+    email?: string;
+
+    /**
+     * The contact's associated runner groups.
+     */
+    @IsObject()
+    groups: ResponseRunnerGroup[];
+
+    /**
+     * The contact's address.
+     * This is a address object to prevent any formatting differences.
+     */
+    @IsObject()
+    address?: Address;
+
+    /**
+     * Creates a ResponseGroupContact object from a contact.
+     * @param contact The contact the response shall be build for.
+     */
+    public constructor(contact: GroupContact) {
+        this.id = contact.id;
+        this.firstname = contact.firstname;
+        this.middlename = contact.middlename;
+        this.lastname = contact.lastname;
+        this.phone = contact.phone;
+        this.email = contact.email;
+        this.address = contact.address;
+        this.groups = new Array<ResponseRunnerGroup>();
+        for (let group of contact.groups) {
+            this.groups.push(group.toResponse());
+        }
+    }
+}
--- a/src/models/responses/ResponseParticipant.ts
+++ b/src/models/responses/ResponseParticipant.ts
@@ -1,4 +1,5 @@
-import { IsInt, IsString } from "class-validator";
+import { IsInt, IsObject, IsOptional, IsString } from "class-validator";
+import { Address } from '../entities/Address';
 import { Participant } from '../entities/Participant';

 /**
@@ -41,6 +42,13 @@ export abstract class ResponseParticipant {
    @IsString()
    email?: string;

+    /**
+     * The participant's address.
+     */
+    @IsOptional()
+    @IsObject()
+    address?: Address;
+
    /**
     * Creates a ResponseParticipant object from a participant.
     * @param participant The participant the response shall be build for.
@@ -52,5 +60,6 @@ export abstract class ResponseParticipant {
        this.lastname = participant.lastname;
        this.phone = participant.phone;
        this.email = participant.email;
+        this.address = participant.address;
    }
 }
--- a/src/models/responses/ResponseRunnerOrganisation.ts
+++ b/src/models/responses/ResponseRunnerOrganisation.ts
@@ -1,39 +0,0 @@
-import {
-    IsArray,
-
-    IsObject,
-    IsOptional
-} from "class-validator";
-import { Address } from '../entities/Address';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
-import { RunnerTeam } from '../entities/RunnerTeam';
-import { ResponseRunnerGroup } from './ResponseRunnerGroup';
-
-/**
- * Defines the runnerOrganisation response.
-*/
-export class ResponseRunnerOrganisation extends ResponseRunnerGroup {
-
-    /**
-     * The runnerOrganisation's address.
-     */
-    @IsObject()
-    @IsOptional()
-    address?: Address;
-
-    /**
-     * The runnerOrganisation associated teams.
-     */
-    @IsArray()
-    teams: RunnerTeam[];
-
-    /**
-     * Creates a ResponseRunnerOrganisation object from a runnerOrganisation.
-     * @param org The runnerOrganisation the response shall be build for.
-     */
-    public constructor(org: RunnerOrganisation) {
-        super(org);
-        this.address = org.address;
-        this.teams = org.teams;
-    }
-}
--- a/src/models/responses/ResponseRunnerOrganization.ts
+++ b/src/models/responses/ResponseRunnerOrganization.ts
@@ -0,0 +1,62 @@
+import {
+    IsArray,
+
+    IsBase64,
+
+    IsBoolean,
+
+    IsObject,
+    IsOptional,
+    IsString
+} from "class-validator";
+import { Address } from '../entities/Address';
+import { RunnerOrganization } from '../entities/RunnerOrganization';
+import { RunnerTeam } from '../entities/RunnerTeam';
+import { ResponseRunnerGroup } from './ResponseRunnerGroup';
+
+/**
+ * Defines the runnerOrganization response.
+*/
+export class ResponseRunnerOrganization extends ResponseRunnerGroup {
+
+    /**
+     * The runnerOrganization's address.
+     */
+    @IsObject()
+    @IsOptional()
+    address?: Address;
+
+    /**
+     * The runnerOrganization associated teams.
+     */
+    @IsArray()
+    teams: RunnerTeam[];
+
+    /**
+     * The organization's registration key.
+     * If registration is disabled this is null.
+     */
+    @IsString()
+    @IsOptional()
+    @IsBase64()
+    registrationKey?: string;
+
+    /**
+     * Is registration enabled for the organization?
+     */
+    @IsOptional()
+    @IsBoolean()
+    registrationEnabled?: boolean = true;
+
+    /**
+     * Creates a ResponseRunnerOrganization object from a runnerOrganization.
+     * @param org The runnerOrganization the response shall be build for.
+     */
+    public constructor(org: RunnerOrganization) {
+        super(org);
+        this.address = org.address;
+        this.teams = org.teams;
+        if (!org.key) { this.registrationEnabled = false; }
+        else { this.registrationKey = Buffer.from(org.key).toString('base64'); }
+    }
+}
--- a/src/models/responses/ResponseRunnerTeam.ts
+++ b/src/models/responses/ResponseRunnerTeam.ts
@@ -1,7 +1,7 @@
 import { IsNotEmpty, IsObject } from "class-validator";
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
 import { RunnerTeam } from '../entities/RunnerTeam';
 import { ResponseRunnerGroup } from './ResponseRunnerGroup';
+import { ResponseRunnerOrganization } from './ResponseRunnerOrganization';

 /**
 * Defines the runnerTeam response.
@@ -9,11 +9,11 @@ import { ResponseRunnerGroup } from './ResponseRunnerGroup';
 export class ResponseRunnerTeam extends ResponseRunnerGroup {

    /**
-     * The runnerTeam's parent group (organisation).
+     * The runnerTeam's parent group (organization).
     */
    @IsObject()
    @IsNotEmpty()
-    parentGroup: RunnerOrganisation;
+    parentGroup: ResponseRunnerOrganization;

    /**
     * Creates a ResponseRunnerTeam object from a runnerTeam.
@@ -21,6 +21,6 @@ export class ResponseRunnerTeam extends ResponseRunnerGroup {
     */
    public constructor(team: RunnerTeam) {
        super(team);
-        this.parentGroup = team.parentGroup;
+        this.parentGroup = team.parentGroup.toResponse();
    }
 }
--- a/src/models/responses/ResponseSelfServiceDonation.ts
+++ b/src/models/responses/ResponseSelfServiceDonation.ts
@@ -0,0 +1,36 @@
+import { IsInt, IsNotEmpty, IsPositive } from 'class-validator';
+import { DistanceDonation } from '../entities/DistanceDonation';
+
+/**
+ * Defines the runner selfservice donation response.
+ * Why? B/C runner's are not allowed to view all information available to admin users.
+*/
+export class ResponseSelfServiceDonation {
+    /**
+     * The donation's donor.
+     */
+    @IsNotEmpty()
+    donor: string;
+
+    /**
+     * The donation's amount in the smalles unit of your currency (default: euro cent).
+     */
+    @IsInt()
+    amount: number;
+
+    /**
+     * The donation's amount donated per distance.
+     * The amount the donor set to be donated per kilometer that the runner ran.
+     */
+    @IsInt()
+    @IsPositive()
+    amountPerDistance: number;
+
+    public constructor(donation: DistanceDonation) {
+        if (!donation.donor.middlename) { this.donor = donation.donor.firstname + " " + donation.donor.lastname; }
+        else { this.donor = donation.donor.firstname + " " + donation.donor.middlename + " " + donation.donor.lastname; }
+
+        this.amountPerDistance = donation.amountPerDistance;
+        this.amount = donation.amount;
+    }
+}
--- a/src/models/responses/ResponseSelfServiceRunner.ts
+++ b/src/models/responses/ResponseSelfServiceRunner.ts
@@ -0,0 +1,83 @@
+import { IsInt, IsOptional, IsString } from "class-validator";
+import { DistanceDonation } from '../entities/DistanceDonation';
+import { Runner } from '../entities/Runner';
+import { RunnerGroup } from '../entities/RunnerGroup';
+import { RunnerTeam } from '../entities/RunnerTeam';
+import { ResponseParticipant } from './ResponseParticipant';
+import { ResponseSelfServiceDonation } from './ResponseSelfServiceDonation';
+
+/**
+ * Defines the runner selfservice response.
+ * Why? B/C runner's are not allowed to view all information available to admin users.
+*/
+export class ResponseSelfServiceRunner extends ResponseParticipant {
+
+    /**
+     * The runner's currently ran distance in meters.
+     */
+    @IsInt()
+    distance: number;
+
+    /**
+     * The runner's currently collected donations.
+     */
+    @IsInt()
+    donationAmount: number;
+
+    /**
+     * The runner's group as a string (mix of org and team).
+     */
+    @IsString()
+    group: string;
+
+    /**
+     * The runner's associated donations.
+     */
+    @IsString()
+    donations: ResponseSelfServiceDonation[]
+
+    /**
+     * The runner's self-service jwt for auth.
+     * Will only get delivered on registration/via email.
+     */
+    @IsString()
+    @IsOptional()
+    token: string;
+
+    /**
+     * Creates a ResponseRunner object from a runner.
+     * @param runner The user the response shall be build for.
+     */
+    public constructor(runner: Runner) {
+        super(runner);
+        this.distance = runner.distance;
+        this.donationAmount = runner.distanceDonationAmount;
+        this.group = this.getTeamString(runner.group);
+        this.donations = this.getDonations(runner.distanceDonations);
+    }
+
+    /**
+     * Parses a runner's group into a string.
+     * If the runner's group is a team: `org name/team name`
+     * If the runner's group is an org: `org name`
+     * @param group The group that shall get parsed to a string.
+     */
+    private getTeamString(group: RunnerGroup): string {
+        if (group instanceof RunnerTeam) {
+            return group.parentGroup.name + "/" + group.name;
+        }
+        return group.name;
+    }
+
+    /**
+     * Converts all of the runner's donations to ResponseSelfServiceDonations.
+     * @param donations The donations that shall be converted to ResponseSelfServiceDonations.
+     */
+    private getDonations(donations: DistanceDonation[]): ResponseSelfServiceDonation[] {
+        let responseDonations = new Array<ResponseSelfServiceDonation>();
+        for (let donation of donations) {
+            responseDonations.push(new ResponseSelfServiceDonation(donation));
+        }
+        return responseDonations;
+    }
+}
--- a/src/models/responses/ResponseStats.ts
+++ b/src/models/responses/ResponseStats.ts
@@ -3,7 +3,7 @@ import {
 } from "class-validator";
 import { Donation } from '../entities/Donation';
 import { Runner } from '../entities/Runner';
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
+import { RunnerOrganization } from '../entities/RunnerOrganization';
 import { RunnerTeam } from '../entities/RunnerTeam';
 import { Scan } from '../entities/Scan';
 import { User } from '../entities/User';
@@ -26,7 +26,7 @@ export class ResponseStats {
    total_teams: number;

    /**
-     * The amount of organisations registered in the system.
+     * The amount of organizations registered in the system.
     */
    @IsInt()
    total_orgs: number;
@@ -70,7 +70,7 @@ export class ResponseStats {
     * @param scans Array containing all scans - no relations have to be resolved.
     * @param donations Array containing all donations - the following relations have to be resolved: runner, runner.scans, runner.scans.track
     */
-    public constructor(runners: Runner[], teams: RunnerTeam[], orgs: RunnerOrganisation[], users: User[], scans: Scan[], donations: Donation[]) {
+    public constructor(runners: Runner[], teams: RunnerTeam[], orgs: RunnerOrganization[], users: User[], scans: Scan[], donations: Donation[]) {
        this.total_runners = runners.length;
        this.total_teams = teams.length;
        this.total_orgs = orgs.length;
--- a/src/models/responses/ResponseStatsOrganization.ts
+++ b/src/models/responses/ResponseStatsOrganization.ts
@@ -3,7 +3,7 @@ import {

    IsString
 } from "class-validator";
-import { RunnerOrganisation } from '../entities/RunnerOrganisation';
+import { RunnerOrganization } from '../entities/RunnerOrganization';

 /**
 * Defines the org stats response.
@@ -35,10 +35,10 @@ export class ResponseStatsOrgnisation {
    donationAmount: number;

    /**
-     * Creates a new organisation stats response from a organisation
-     * @param org The organisation whoes response shall be generated - the following relations have to be resolved: runners, runners.scans, runners.distanceDonations, runners.scans.track, teams, teams.runners, teams.runners.scans, teams.runners.distanceDonations, teams.runners.scans.track
+     * Creates a new organization stats response from a organization
+     * @param org The organization whoes response shall be generated - the following relations have to be resolved: runners, runners.scans, runners.distanceDonations, runners.scans.track, teams, teams.runners, teams.runners.scans, teams.runners.distanceDonations, teams.runners.scans.track
     */
-    public constructor(org: RunnerOrganisation) {
+    public constructor(org: RunnerOrganization) {
        this.name = org.name;
        this.id = org.id;
        this.distance = org.distance;
--- a/src/models/responses/ResponseUser.ts
+++ b/src/models/responses/ResponseUser.ts
@@ -1,97 +1,99 @@
-import {
-    IsArray,
-    IsBoolean,
-
-    IsOptional,
-    IsString
-} from "class-validator";
-import { User } from '../entities/User';
-import { UserGroup } from '../entities/UserGroup';
-import { ResponsePrincipal } from './ResponsePrincipal';
-
-/**
- * Defines the user response.
-*/
-export class ResponseUser extends ResponsePrincipal {
-    /**
-     * The user's first name.
-     */
-    @IsString()
-    firstname: string;
-
-    /**
-     * The user's middle name.
-     */
-    @IsString()
-    middlename?: string;
-
-    /**
-     * The user's last name.
-     */
-    @IsString()
-    lastname: string;
-
-    /**
-     * The user's phone number.
-     */
-    @IsString()
-    phone?: string;
-
-    /**
-     * The user's e-mail address.
-     */
-    @IsString()
-    email?: string;
-
-    /**
-     * The user's username.
-     */
-    @IsString()
-    username?: string;
-
-    /**
-    * Is user enabled?
-    */
-    @IsBoolean()
-    enabled: boolean = true;
-
-    /**
-    * The user's profile pic (or rather a url pointing to it).
-    */
-    @IsString()
-    profilePic: string;
-
-    /**
-     * The groups that the user is a part of.
-     */
-    @IsArray()
-    @IsOptional()
-    groups: UserGroup[];
-
-    /**
-     * The user's permissions.
-     * Directly granted or inherited converted to their string form and deduplicated.
-     */
-    @IsArray()
-    @IsOptional()
-    permissions: string[];
-
-    /**
-     * Creates a ResponseUser object from a user.
-     * @param user The user the response shall be build for.
-     */
-    public constructor(user: User) {
-        super(user);
-        this.firstname = user.firstname;
-        this.middlename = user.middlename;
-        this.lastname = user.lastname;
-        this.phone = user.phone;
-        this.email = user.email;
-        this.username = user.username;
-        this.enabled = user.enabled;
-        this.profilePic = user.profilePic;
-        this.groups = user.groups;
-        this.permissions = user.allPermissions;
-        this.groups.forEach(function (g) { delete g.permissions });
-    }
-}
+import {
+    IsArray,
+    IsBoolean,
+
+    IsOptional,
+    IsString
+} from "class-validator";
+import { User } from '../entities/User';
+import { UserGroup } from '../entities/UserGroup';
+import { ResponsePrincipal } from './ResponsePrincipal';
+
+/**
+ * Defines the user response.
+*/
+export class ResponseUser extends ResponsePrincipal {
+    /**
+     * The user's first name.
+     */
+    @IsString()
+    firstname: string;
+
+    /**
+     * The user's middle name.
+     */
+    @IsString()
+    middlename?: string;
+
+    /**
+     * The user's last name.
+     */
+    @IsString()
+    lastname: string;
+
+    /**
+     * The user's phone number.
+     */
+    @IsString()
+    phone?: string;
+
+    /**
+     * The user's e-mail address.
+     */
+    @IsString()
+    email?: string;
+
+    /**
+     * The user's username.
+     */
+    @IsString()
+    username?: string;
+
+    /**
+    * Is user enabled?
+    */
+    @IsBoolean()
+    enabled: boolean = true;
+
+    /**
+    * The user's profile pic (or rather a url pointing to it).
+    */
+    @IsString()
+    profilePic: string;
+
+    /**
+     * The groups that the user is a part of.
+     */
+    @IsArray()
+    @IsOptional()
+    groups: UserGroup[];
+
+    /**
+     * The user's permissions.
+     * Directly granted or inherited converted to their string form and deduplicated.
+     */
+    @IsArray()
+    @IsOptional()
+    permissions: string[];
+
+    /**
+     * Creates a ResponseUser object from a user.
+     * @param user The user the response shall be build for.
+     */
+    public constructor(user: User) {
+        super(user);
+        this.firstname = user.firstname;
+        this.middlename = user.middlename;
+        this.lastname = user.lastname;
+        this.phone = user.phone;
+        this.email = user.email;
+        this.username = user.username;
+        this.enabled = user.enabled;
+        this.profilePic = user.profilePic;
+        this.groups = user.groups;
+        this.permissions = user.allPermissions;
+        if (this.groups) {
+            this.groups.forEach(function (g) { delete g.permissions });
+        }
+    }
+}
--- a/src/models/responses/ResponseUserGroup.ts
+++ b/src/models/responses/ResponseUserGroup.ts
@@ -1,41 +1,41 @@
-import { IsArray, IsNotEmpty, IsOptional, IsString } from "class-validator";
-import { Permission } from '../entities/Permission';
-import { UserGroup } from '../entities/UserGroup';
-import { ResponsePrincipal } from './ResponsePrincipal';
-
-/**
- * Defines the userGroup response.
-*/
-export class ResponseUserGroup extends ResponsePrincipal {
-    /**
-     * The userGroup's name.
-     */
-    @IsNotEmpty()
-    @IsString()
-    name: string;
-
-    /**
-     * The userGroup's description.
-     */
-    @IsOptional()
-    @IsString()
-    description?: string;
-
-    /**
-     * The userGroup's permissions.
-     */
-    @IsArray()
-    @IsOptional()
-    permissions: Permission[];
-
-    /**
-     * Creates a ResponseUserGroup object from a userGroup.
-     * @param group The userGroup the response shall be build for.
-     */
-    public constructor(group: UserGroup) {
-        super(group);
-        this.name = group.name;
-        this.description = group.description;
-        this.permissions = group.permissions;
-    }
-}
+import { IsArray, IsNotEmpty, IsOptional, IsString } from "class-validator";
+import { Permission } from '../entities/Permission';
+import { UserGroup } from '../entities/UserGroup';
+import { ResponsePrincipal } from './ResponsePrincipal';
+
+/**
+ * Defines the userGroup response.
+*/
+export class ResponseUserGroup extends ResponsePrincipal {
+    /**
+     * The userGroup's name.
+     */
+    @IsNotEmpty()
+    @IsString()
+    name: string;
+
+    /**
+     * The userGroup's description.
+     */
+    @IsOptional()
+    @IsString()
+    description?: string;
+
+    /**
+     * The userGroup's permissions.
+     */
+    @IsArray()
+    @IsOptional()
+    permissions: Permission[];
+
+    /**
+     * Creates a ResponseUserGroup object from a userGroup.
+     * @param group The userGroup the response shall be build for.
+     */
+    public constructor(group: UserGroup) {
+        super(group);
+        this.name = group.name;
+        this.description = group.description;
+        this.permissions = group.permissions;
+    }
+}
--- a/src/seeds/SeedPublicOrg.ts
+++ b/src/seeds/SeedPublicOrg.ts
@@ -0,0 +1,15 @@
+import { Connection } from 'typeorm';
+import { Factory, Seeder } from 'typeorm-seeding';
+import { CreateRunnerOrganization } from '../models/actions/create/CreateRunnerOrganization';
+import { RunnerOrganization } from '../models/entities/RunnerOrganization';
+
+/**
+ * Seeds the public runner org (named: "Citizen" by default).
+ */
+export default class SeedPublicOrg implements Seeder {
+    public async run(factory: Factory, connection: Connection): Promise<any> {
+        let publicOrg = new CreateRunnerOrganization();
+        publicOrg.name = "Citizen";
+        await connection.getRepository(RunnerOrganization).save(await publicOrg.toEntity());
+    }
+}
--- a/src/seeds/SeedTestRunners.ts
+++ b/src/seeds/SeedTestRunners.ts
@@ -0,0 +1,93 @@
+import { Connection } from 'typeorm';
+import { Factory, Seeder } from 'typeorm-seeding';
+import { CreateGroupContact } from '../models/actions/create/CreateGroupContact';
+import { CreateRunner } from '../models/actions/create/CreateRunner';
+import { CreateRunnerOrganization } from '../models/actions/create/CreateRunnerOrganization';
+import { CreateRunnerTeam } from '../models/actions/create/CreateRunnerTeam';
+import { Address } from '../models/entities/Address';
+import { GroupContact } from '../models/entities/GroupContact';
+import { Runner } from '../models/entities/Runner';
+import { RunnerGroup } from '../models/entities/RunnerGroup';
+import { RunnerOrganization } from '../models/entities/RunnerOrganization';
+import { RunnerTeam } from '../models/entities/RunnerTeam';
+
+/**
+ * Seeds a test runner org with a test runner team ans some test runners.
+ * Usefull for testing or demo instances.
+ */
+export default class SeedTestRunners implements Seeder {
+    public async run(factory: Factory, connection: Connection): Promise<any> {
+        let testOrg: RunnerOrganization = await this.createTestOrg(connection);
+        let testTeam: RunnerTeam = await this.createTestTeam(connection, testOrg);
+        await this.createTestContact(connection, testOrg);
+        await this.createTestRunners(connection, testOrg);
+        await this.createTestRunners(connection, testTeam);
+    }
+
+    public async createTestOrg(connection: Connection): Promise<RunnerOrganization> {
+        let testOrg = new CreateRunnerOrganization();
+        testOrg.name = "Test Org";
+
+        testOrg.address = new Address();
+        testOrg.address.address1 = "Test street 1";
+        testOrg.address.city = "Herzogenaurach";
+        testOrg.address.country = "Germany";
+        testOrg.address.postalcode = "90174";
+
+        return await connection.getRepository(RunnerOrganization).save(await testOrg.toEntity());
+    }
+
+    public async createTestTeam(connection: Connection, org: RunnerOrganization): Promise<RunnerTeam> {
+        let testTeam = new CreateRunnerTeam();
+        testTeam.name = "Test Team";
+        testTeam.parentGroup = org.id;
+
+        return await connection.getRepository(RunnerTeam).save(await testTeam.toEntity());
+    }
+
+    public async createTestRunners(connection: Connection, group: RunnerGroup) {
+        for (let first of this.firstnames) {
+            for (let last of this.lastnames) {
+                let runner = new CreateRunner;
+                runner.firstname = first;
+                runner.lastname = last;
+                runner.middlename = group.name;
+                runner.group = group.id;
+                await connection.getRepository(Runner).save(await runner.toEntity());
+            }
+        }
+    }
+
+    public async createTestContact(connection: Connection, group: RunnerGroup) {
+        let contact = new CreateGroupContact;
+        contact.firstname = "Test";
+        contact.lastname = "Contact";
+        contact.email = "test.contact@dev.lauf-fuer-kaya.de";
+        contact.groups = group.id;
+
+        contact.address = new Address();
+        contact.address.address1 = "First Contact Street 100";
+        contact.address.city = "Herzogenaurach";
+        contact.address.country = "Germany";
+        contact.address.postalcode = "90174";
+
+        await connection.getRepository(GroupContact).save(await contact.toEntity());
+    }
+
+    private firstnames = [
+        "Peter",
+        "Matze",
+        "Tine",
+        "Uta",
+        "Fabian",
+        "Unicode:ÖÄ?✔⚠"
+    ]
+
+    private lastnames = [
+        "Muster",
+        "Example",
+        "Müller",
+        "Unicode:搆Ǩ>ÙՠƳ|"
+    ]
+
+}
--- a/src/tests/cards/cards_add.spec.ts
+++ b/src/tests/cards/cards_add.spec.ts
@@ -69,7 +69,7 @@ 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', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
--- a/src/tests/cards/cards_update.spec.ts
+++ b/src/tests/cards/cards_update.spec.ts
@@ -50,7 +50,7 @@ describe('adding + updating card.runner successfully', () => {
 	let added_runner2;
 	let added_card;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
--- a/src/tests/contacts/contact_add.spec.ts
+++ b/src/tests/contacts/contact_add.spec.ts
@@ -0,0 +1,215 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+// ---------------
+describe('POST /api/contacts with errors', () => {
+    it('creating a new contact without any parameters should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', null, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact without a last name should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle"
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid phone number should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle",
+            "lastname": "last",
+            "phone": "123"
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid mail address should return 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "phone": null,
+            "email": "123",
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with an invalid address 400', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "address": {
+                "city": "Testcity"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a invalid group should return 404', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "groups": 9999999999999
+        }, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('POST /api/contacts working (simple)', () => {
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with all non-relationship optional params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "middlename": "middle",
+            "lastname": "last",
+            "email": "testContact@lauf-fuer-kaya.de",
+            "phone": "+49017612345678",
+            "address": {
+                "address1": "test",
+                "address2": null,
+                "city": "herzogenaurach",
+                "country": "germany",
+                "postalcode": "91074",
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('POST /api/contacts working (with group)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('creating a new contact with a valid team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_team]
+        });
+    });
+    it('creating a new contact with a valid org and team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        delete res.data.id;
+        expect(res.data).toEqual({
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org, added_team]
+        });
+    });
+    it('checking if the added team\'s contact is the new contact should return 200', async () => {
+        const res = await axios.get(base + '/api/teams/' + added_team.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        delete res.data.contact.groups;
+        delete res.data.contact.id;
+        delete added_contact.groups;
+        expect(res.data.contact).toEqual(added_contact);
+    });
+});
--- a/src/tests/contacts/contact_delete.spec.ts
+++ b/src/tests/contacts/contact_delete.spec.ts
@@ -0,0 +1,183 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('adding + deletion (non-existant)', () => {
+    it('delete', async () => {
+        const res = await axios.delete(base + '/api/contacts/0', axios_config);
+        expect(res.status).toEqual(204);
+    });
+});
+// ---------------
+describe('add+delete (simple)', () => {
+    let added_contact;
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let deleted_contact = res.data
+        expect(deleted_contact).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with org)', () => {
+    let added_org;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with team)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('add+delete (with org&team)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.parentGroup;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org and team should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('delete contact', async () => {
+        const res = await axios.delete(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        delete res.data.groups[0].contact;
+        delete res.data.groups[1].contact;
+        expect(res.data).toEqual(added_contact);
+    });
+    it('check if contact really was deleted', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
--- a/src/tests/contacts/contact_get.spec.ts
+++ b/src/tests/contacts/contact_get.spec.ts
@@ -0,0 +1,57 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('GET /api/contacts', () => {
+    it('basic get should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts', axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('GET /api/contacts/0', () => {
+    it('basic get should return 404', async () => {
+        const res = await axios.get(base + '/api/contacts/0', axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('GET /api/contacts after adding', () => {
+    let added_contact;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('explicit get should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts/' + added_contact.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_donor = res.data
+        expect(gotten_donor).toEqual(added_contact);
+    });
+    it('get from all runners should return 200', async () => {
+        const res = await axios.get(base + '/api/contacts/', axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_donors = res.data
+        expect(gotten_donors).toContainEqual(added_contact);
+    });
+});
--- a/src/tests/contacts/contact_update.spec.ts
+++ b/src/tests/contacts/contact_update.spec.ts
@@ -0,0 +1,237 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('Update contact name after adding', () => {
+    let added_contact;
+    it('creating a new contact with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('valid update should return 200', async () => {
+        let contact_copy = added_contact
+        contact_copy.firstname = "second"
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, contact_copy, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        expect(res.data).toEqual(contact_copy);
+    });
+});
+// ---------------
+describe('Update contact id after adding(should fail)', () => {
+    let added_contact;
+    it('creating a new donor with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last"
+        }, axios_config);
+        added_contact = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('invalid update should return 406', async () => {
+        added_contact.id++;
+        const res = await axios.put(base + '/api/contacts/' + (added_contact.id - 1), added_contact, axios_config);
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('Update contact group after adding (should work)', () => {
+    let added_org;
+    let added_team;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org.id
+        }, axios_config);
+        delete res.data.contact;
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('valid group update to single team should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_team.id
+        }, axios_config);
+        console.log(res.data)
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_team]
+        });
+    });
+    it('valid group update to org and team should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": [added_org.id, added_team.id]
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org, added_team]
+        });
+    });
+    it('valid group update to none should return 200', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": null
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": []
+        });
+    });
+});
+// ---------------
+describe('Update contact group invalid after adding (should fail)', () => {
+    let added_org;
+    let added_contact;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        delete res.data.contact;
+        delete res.data.teams;
+        added_org = res.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new contact with a valid org should return 200', async () => {
+        const res = await axios.post(base + '/api/contacts', {
+            "firstname": "first",
+            "lastname": "last",
+            "groups": added_org.id
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_contact = res.data
+        expect(res.data).toEqual({
+            "id": res.data.id,
+            "firstname": "first",
+            "middlename": null,
+            "lastname": "last",
+            "phone": null,
+            "email": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "postalcode": null,
+                "city": null,
+                "country": null
+            },
+            "groups": [added_org]
+        });
+    });
+    it('invalid group update to single team should return 404', async () => {
+        const res = await axios.put(base + '/api/contacts/' + added_contact.id, {
+            "id": added_contact.id,
+            "firstname": "first",
+            "lastname": "last",
+            "groups": 999999999999999
+        }, axios_config);
+        expect(res.status).toEqual(404);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+});
--- a/src/tests/donations/donations_add.spec.ts
+++ b/src/tests/donations/donations_add.spec.ts
@@ -83,7 +83,7 @@ describe('POST /api/donations/distance illegally', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
@@ -199,7 +199,7 @@ describe('POST /api/donations/distance successfully', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
--- a/src/tests/donations/donations_delete.spec.ts
+++ b/src/tests/donations/donations_delete.spec.ts
@@ -70,7 +70,7 @@ describe('DELETE distance donation', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
--- a/src/tests/donations/donations_get.spec.ts
+++ b/src/tests/donations/donations_get.spec.ts
@@ -73,7 +73,7 @@ describe('adding + getting distance donation', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
--- a/src/tests/donations/donations_update.spec.ts
+++ b/src/tests/donations/donations_update.spec.ts
@@ -84,7 +84,7 @@ describe('adding + updating distance donation illegally', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
@@ -253,7 +253,7 @@ describe('adding + updating distance donation valid', () => {
 		expect(res.headers['content-type']).toContain("application/json")
 	});
 	it('creating a new org with just a name should return 200', async () => {
-		const res = await axios.post(base + '/api/organisations', {
+		const res = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res.data
--- a/src/tests/donors/donor_add.spec.ts
+++ b/src/tests/donors/donor_add.spec.ts
@@ -29,16 +29,6 @@ describe('POST /api/donors with errors', () => {
        expect(res2.status).toEqual(400);
        expect(res2.headers['content-type']).toContain("application/json")
    });
-    it('creating a new donor with a invalid address should return 404', async () => {
-        const res2 = await axios.post(base + '/api/donors', {
-            "firstname": "first",
-            "middlename": "middle",
-            "lastname": "last",
-            "address": 99999999999999999999999999
-        }, axios_config);
-        expect(res2.status).toEqual(404);
-        expect(res2.headers['content-type']).toContain("application/json")
-    });
    it('creating a new donor with a invalid phone number should return 400', async () => {
        const res2 = await axios.post(base + '/api/donors', {
            "firstname": "first",
--- a/src/tests/donors/donor_delete.spec.ts
+++ b/src/tests/donors/donor_delete.spec.ts
@@ -60,7 +60,7 @@ describe('DELETE donor with donations invalid', () => {
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res.data
@@ -115,7 +115,7 @@ describe('DELETE donor with donations valid', () => {
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res.data
--- a/src/tests/donors/donor_update.spec.ts
+++ b/src/tests/donors/donor_update.spec.ts
@@ -60,7 +60,7 @@ describe('Update donor without address but receiptNeeded=true should fail', () =
    it('creating a new donor with only needed params should return 200', async () => {
        const res2 = await axios.post(base + '/api/donors', {
            "firstname": "first",
-            "lastname": "last",
+            "lastname": "testtest",
        }, axios_config);
        added_donor = res2.data;
        expect(res2.status).toEqual(200);
--- a/src/tests/runnerOrgs/org_add.spec.ts
+++ b/src/tests/runnerOrgs/org_add.spec.ts
@@ -14,24 +14,24 @@ beforeAll(async () => {
    };
 });

-describe('GET /api/organisations', () => {
+describe('GET /api/organizations', () => {
    it('basic get should return 200', async () => {
-        const res = await axios.get(base + '/api/organisations', axios_config);
+        const res = await axios.get(base + '/api/organizations', axios_config);
        expect(res.status).toEqual(200);
        expect(res.headers['content-type']).toContain("application/json")
    });
 });
 // ---------------
-describe('POST /api/organisations', () => {
+describe('POST /api/organizations', () => {
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        expect(res.status).toEqual(200);
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with without a name should return 400', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": null
        }, axios_config);
        expect(res.status).toEqual(400);
@@ -41,14 +41,14 @@ describe('POST /api/organisations', () => {
 // ---------------
 describe('adding + getting from all orgs', () => {
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        expect(res.status).toEqual(200);
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('check if org was added', async () => {
-        const res = await axios.get(base + '/api/organisations', axios_config);
+        const res = await axios.get(base + '/api/organizations', axios_config);
        expect(res.status).toEqual(200);
        expect(res.headers['content-type']).toContain("application/json")
        let added_org = res.data[res.data.length - 1]
@@ -56,7 +56,14 @@ describe('adding + getting from all orgs', () => {
        expect(added_org).toEqual({
            "name": "test123",
            "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
+            "registrationEnabled": false,
            "teams": []
        })
    });
@@ -65,7 +72,7 @@ describe('adding + getting from all orgs', () => {
 describe('adding + getting explicitly', () => {
    let added_org_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
@@ -74,7 +81,7 @@ describe('adding + getting explicitly', () => {
        expect(res1.headers['content-type']).toContain("application/json")
    });
    it('check if org was added', async () => {
-        const res2 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
+        const res2 = await axios.get(base + '/api/organizations/' + added_org_id, axios_config);
        expect(res2.status).toEqual(200);
        expect(res2.headers['content-type']).toContain("application/json")
        let added_org2 = res2.data
@@ -83,7 +90,14 @@ describe('adding + getting explicitly', () => {
        expect(added_org2).toEqual({
            "name": "test123",
            "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
+            "registrationEnabled": false,
            "teams": []
        })
    });
--- a/src/tests/runnerOrgs/org_delete.spec.ts
+++ b/src/tests/runnerOrgs/org_delete.spec.ts
@@ -17,7 +17,7 @@ beforeAll(async () => {
 // ---------------
 describe('adding + deletion (non-existant)', () => {
    it('delete', async () => {
-        const res2 = await axios.delete(base + '/api/organisations/0', axios_config);
+        const res2 = await axios.delete(base + '/api/organizations/0', axios_config);
        expect(res2.status).toEqual(204);
    });
 });
@@ -26,7 +26,7 @@ describe('adding + deletion (successfull)', () => {
    let added_org_id
    let added_org
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data
@@ -35,7 +35,7 @@ describe('adding + deletion (successfull)', () => {
        expect(res1.headers['content-type']).toContain("application/json")
    });
    it('delete', async () => {
-        const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config);
+        const res2 = await axios.delete(base + '/api/organizations/' + added_org_id, axios_config);
        expect(res2.status).toEqual(200);
        expect(res2.headers['content-type']).toContain("application/json")
        let added_org2 = res2.data
@@ -44,12 +44,19 @@ describe('adding + deletion (successfull)', () => {
        expect(added_org2).toEqual({
            "name": "test123",
            "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
+            "registrationEnabled": false,
            "teams": []
        });
    });
    it('check if org really was deleted', async () => {
-        const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
+        const res3 = await axios.get(base + '/api/organizations/' + added_org_id, axios_config);
        expect(res3.status).toEqual(404);
        expect(res3.headers['content-type']).toContain("application/json")
    });
@@ -61,7 +68,7 @@ describe('adding + deletion with teams still existing (without force)', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
@@ -80,7 +87,7 @@ describe('adding + deletion with teams still existing (without force)', () => {
        expect(res2.headers['content-type']).toContain("application/json")
    });
    it('delete org - this should fail with a 406', async () => {
-        const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config);
+        const res2 = await axios.delete(base + '/api/organizations/' + added_org_id, axios_config);
        expect(res2.status).toEqual(406);
        expect(res2.headers['content-type']).toContain("application/json")
    });
@@ -92,7 +99,7 @@ describe('adding + deletion with teams still existing (with force)', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
@@ -111,7 +118,7 @@ describe('adding + deletion with teams still existing (with force)', () => {
        expect(res2.headers['content-type']).toContain("application/json")
    });
    it('delete', async () => {
-        const res2 = await axios.delete(base + '/api/organisations/' + added_org_id + '?force=true', axios_config);
+        const res2 = await axios.delete(base + '/api/organizations/' + added_org_id + '?force=true', axios_config);
        expect(res2.status).toEqual(200);
        expect(res2.headers['content-type']).toContain("application/json")
        let added_org2 = res2.data
@@ -121,11 +128,18 @@ describe('adding + deletion with teams still existing (with force)', () => {
        expect(added_org2).toEqual({
            "name": "test123",
            "contact": null,
-            "address": null
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
+            "registrationEnabled": false,
        });
    });
    it('check if org really was deleted', async () => {
-        const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
+        const res3 = await axios.get(base + '/api/organizations/' + added_org_id, axios_config);
        expect(res3.status).toEqual(404);
        expect(res3.headers['content-type']).toContain("application/json")
    });
--- a/src/tests/runnerOrgs/org_get.spec.ts
+++ b/src/tests/runnerOrgs/org_get.spec.ts
@@ -14,15 +14,15 @@ beforeAll(async () => {
    };
 });

-describe('GET /api/organisations', () => {
+describe('GET /api/organizations', () => {
    it('basic get should return 200', async () => {
-        const res = await axios.get(base + '/api/organisations', axios_config);
+        const res = await axios.get(base + '/api/organizations', axios_config);
        expect(res.status).toEqual(200);
        expect(res.headers['content-type']).toContain("application/json")
    });
 });
 // ---------------
-describe('GET /api/organisations/0', () => {
+describe('GET /api/organizations/0', () => {
    it('basic get should return 404', async () => {
        const res = await axios.get(base + '/api/runners/0', axios_config);
        expect(res.status).toEqual(404);
--- a/src/tests/runnerOrgs/org_update.spec.ts
+++ b/src/tests/runnerOrgs/org_update.spec.ts
@@ -19,30 +19,37 @@ describe('adding + updating name', () => {
    let added_org_id
    let added_org
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
-        added_org = res1.data
+        added_org = res.data
        added_org_id = added_org.id;
-        expect(res1.status).toEqual(200);
-        expect(res1.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
    });
    it('update org', async () => {
-        const res2 = await axios.put(base + '/api/organisations/' + added_org_id, {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
            "id": added_org_id,
            "name": "testlelele",
            "contact": null,
            "address": null,
        }, axios_config);
-        expect(res2.status).toEqual(200);
-        expect(res2.headers['content-type']).toContain("application/json")
-        let added_org2 = res2.data
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let added_org2 = res.data
        added_org_id = added_org2.id;
        delete added_org2.id
        expect(added_org2).toEqual({
            "name": "testlelele",
            "contact": null,
-            "address": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null,
+            },
+            "registrationEnabled": false,
            "teams": []
        })
    });
@@ -52,22 +59,333 @@ describe('adding + try updating id (should return 406)', () => {
    let added_org_id
    let added_org
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
-        added_org = res1.data
+        added_org = res.data
        added_org_id = added_org.id;
-        expect(res1.status).toEqual(200);
-        expect(res1.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
    });
    it('update org', async () => {
-        const res2 = await axios.put(base + '/api/organisations/' + added_org_id, {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
            "id": added_org_id + 1,
            "name": "testlelele",
            "contact": null,
            "address": null,
        }, axios_config);
-        expect(res2.status).toEqual(406);
-        expect(res2.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(406);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+});
+// ---------------
+describe('adding + updateing address valid)', () => {
+    let added_org_id
+    let added_org
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('adding address to org should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "Herzogenaurach",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "Herzogenaurach",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('updateing address\'s first line should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('updateing address\'s second line should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('updateing address\'s city should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('updateing address\'s country should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "90174"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('updateing address\'s postal code should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "91065"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test2",
+                "address2": "Test3",
+                "city": "Kaya",
+                "country": "Germany",
+                "postalcode": "91065"
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+    it('removing org\'s address should return 200', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toEqual({
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": null,
+                "country": null,
+                "postalcode": null
+            },
+            "registrationEnabled": false,
+            "teams": []
+        });
+    });
+});
+// ---------------
+describe('adding + updateing address invalid)', () => {
+    let added_org_id
+    let added_org
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('adding address to org w/o address1 should return 400', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": null,
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o city should return 400', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": null,
+                "country": "Burkina Faso",
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o country should return 400', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": null,
+                "postalcode": "90174"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/o postal code should return 400', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": null
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+    it('adding address to org w/ invalid postal code should return 400', async () => {
+        const res = await axios.put(base + '/api/organizations/' + added_org_id, {
+            "id": added_org_id,
+            "name": "testlelele",
+            "contact": null,
+            "address": {
+                "address1": "Test1",
+                "address2": null,
+                "city": "TestCity",
+                "country": "Burkina Faso",
+                "postalcode": "-1"
+            }
+        }, axios_config);
+        expect(res.status).toEqual(400);
+        expect(res.headers['content-type']).toContain("application/json");
    });
 });
--- a/src/tests/runnerTeams/team_add.spec.ts
+++ b/src/tests/runnerTeams/team_add.spec.ts
@@ -58,7 +58,7 @@ describe('POST /api/teams with errors', () => {
 describe('POST /api/teams working', () => {
    let added_org_id;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
--- a/src/tests/runnerTeams/team_delete.spec.ts
+++ b/src/tests/runnerTeams/team_delete.spec.ts
@@ -21,7 +21,7 @@ describe('adding org', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
--- a/src/tests/runnerTeams/team_update.spec.ts
+++ b/src/tests/runnerTeams/team_update.spec.ts
@@ -20,7 +20,7 @@ describe('adding + updating name', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
@@ -59,7 +59,7 @@ describe('adding + try updating id (should return 406)', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
@@ -92,7 +92,7 @@ describe('add+update parent org (valid)', () => {
    let added_team;
    let added_team_id
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data;
@@ -110,7 +110,7 @@ describe('add+update parent org (valid)', () => {
        expect(res2.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res3 = await axios.post(base + '/api/organisations', {
+        const res3 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org2 = res3.data;
@@ -120,12 +120,13 @@ describe('add+update parent org (valid)', () => {
    it('update team', async () => {
        added_team.parentGroup = added_org2.id;
        const res4 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config);
-        let updated_team = res4.data;
        expect(res4.status).toEqual(200);
        expect(res4.headers['content-type']).toContain("application/json")
-        delete added_org2.address;
        delete added_org2.contact;
        delete added_org2.teams;
-        expect(updated_team.parentGroup).toEqual(added_org2)
+        delete added_org2.registrationEnabled;
+        delete res4.data.parentGroup.key;
+        delete res4.data.parentGroup.registrationEnabled;
+        expect(res4.data.parentGroup).toEqual(added_org2)
    });
 });
--- a/src/tests/runners/runner_add.spec.ts
+++ b/src/tests/runners/runner_add.spec.ts
@@ -80,7 +80,7 @@ describe('POST /api/runners with errors', () => {
 describe('POST /api/runners working', () => {
    let added_org_id;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
--- a/src/tests/runners/runner_delete.spec.ts
+++ b/src/tests/runners/runner_delete.spec.ts
@@ -25,7 +25,7 @@ describe('add+delete', () => {
    let added_org_id;
    let added_runner;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
@@ -71,7 +71,7 @@ describe('DELETE donor with donations invalid', () => {
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res.data
@@ -118,7 +118,7 @@ describe('DELETE donor with donations valid', () => {
        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res.data
--- a/src/tests/runners/runner_get.spec.ts
+++ b/src/tests/runners/runner_get.spec.ts
@@ -33,36 +33,106 @@ describe('GET /api/runners after adding', () => {
    let added_org_id;
    let added_runner;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
-        let added_org = res1.data
+        let added_org = res.data
        added_org_id = added_org.id;
-        expect(res1.status).toEqual(200);
-        expect(res1.headers['content-type']).toContain("application/json")
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
    });
    it('creating a new runner with only needed params should return 200', async () => {
-        const res2 = await axios.post(base + '/api/runners', {
+        const res = await axios.post(base + '/api/runners', {
            "firstname": "first",
            "lastname": "last",
            "group": added_org_id
        }, axios_config);
-        added_runner = res2.data;
-        expect(res2.status).toEqual(200);
-        expect(res2.headers['content-type']).toContain("application/json")
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
    });
    it('explicit get should return 200', async () => {
-        const res3 = await axios.get(base + '/api/runners/' + added_runner.id, axios_config);
-        expect(res3.status).toEqual(200);
-        expect(res3.headers['content-type']).toContain("application/json")
-        let gotten_runner = res3.data
+        const res = await axios.get(base + '/api/runners/' + added_runner.id, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_runner = res.data
        expect(gotten_runner).toEqual(added_runner);
    });
    it('get from all runners should return 200', async () => {
-        const res4 = await axios.get(base + '/api/runners/', axios_config);
-        expect(res4.status).toEqual(200);
-        expect(res4.headers['content-type']).toContain("application/json")
-        let gotten_runners = res4.data
+        const res = await axios.get(base + '/api/runners/', axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+        let gotten_runners = res.data
        expect(gotten_runners).toContainEqual(added_runner);
    });
+});
+// ---------------
+describe('GET /api/organizations/:id/runners after adding', () => {
+    let added_org_id;
+    let added_runner;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        let added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_org_id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('check if scans was added via the orgs/runners endpoint.', async () => {
+        const res = await axios.get(base + '/api/organizations/' + added_org_id + "/runners", axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toContainEqual(added_runner);
+    });
+});
+// ---------------
+describe('GET /api/teams/:id/runners after adding', () => {
+    let added_org_id;
+    let added_team;
+    let added_runner;
+    it('creating a new org with just a name should return 200', async () => {
+        const res = await axios.post(base + '/api/organizations', {
+            "name": "test123"
+        }, axios_config);
+        let added_org = res.data
+        added_org_id = added_org.id;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new team with a parent org should return 200', async () => {
+        const res = await axios.post(base + '/api/teams', {
+            "name": "test_team",
+            "parentGroup": added_org_id
+        }, axios_config);
+        added_team = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('creating a new runner with only needed params should return 200', async () => {
+        const res = await axios.post(base + '/api/runners', {
+            "firstname": "first",
+            "lastname": "last",
+            "group": added_team.id
+        }, axios_config);
+        added_runner = res.data;
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json")
+    });
+    it('check if scans was added via the orgs/runners endpoint.', async () => {
+        const res = await axios.get(base + '/api/teams/' + added_team.id + "/runners", axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        expect(res.data).toContainEqual(added_runner);
+    });
 });
--- a/src/tests/runners/runner_update.spec.ts
+++ b/src/tests/runners/runner_update.spec.ts
@@ -17,11 +17,11 @@ beforeAll(async () => {
 describe('Update runner name after adding', () => {
    let added_org;
    let added_runner;
-    let updated_runner;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
+        delete res1.data.registrationEnabled;
        added_org = res1.data
        expect(res1.status).toEqual(200);
        expect(res1.headers['content-type']).toContain("application/json")
@@ -43,12 +43,13 @@ describe('Update runner name after adding', () => {
        const res3 = await axios.put(base + '/api/runners/' + added_runner.id, runnercopy, axios_config);
        expect(res3.status).toEqual(200);
        expect(res3.headers['content-type']).toContain("application/json")
-        updated_runner = res3.data;
-        delete added_org.address;
        delete added_org.contact;
        delete added_org.teams;
        runnercopy.group = added_org;
-        expect(updated_runner).toEqual(runnercopy);
+        delete res3.data.group.key;
+        delete res3.data.group.registrationEnabled;
+        delete runnercopy.group.registrationEnabled;
+        expect(res3.data).toEqual(runnercopy);
    });
 });
 // ---------------
@@ -56,9 +57,8 @@ describe('Update runner group after adding', () => {
    let added_org_id;
    let added_org_2;
    let added_runner;
-    let updated_runner;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
@@ -77,11 +77,10 @@ describe('Update runner group after adding', () => {
        expect(res2.headers['content-type']).toContain("application/json")
    });
    it('creating a new org with just a name should return 200', async () => {
-        const res3 = await axios.post(base + '/api/organisations', {
+        const res3 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org_2 = res3.data
-        delete added_org_2.address;
        delete added_org_2.contact;
        delete added_org_2.teams;
        expect(res3.status).toEqual(200);
@@ -89,11 +88,13 @@ describe('Update runner group after adding', () => {
    });
    it('valid group update should return 200', async () => {
        added_runner.group = added_org_2.id;
+        delete added_org_2.registrationEnabled;
        const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
        expect(res3.status).toEqual(200);
        expect(res3.headers['content-type']).toContain("application/json")
-        updated_runner = res3.data
-        expect(updated_runner.group).toEqual(added_org_2);
+        delete res3.data.group.key;
+        delete res3.data.group.registrationEnabled;
+        expect(res3.data.group).toEqual(added_org_2);
    });
 });
 // ---------------
@@ -102,7 +103,7 @@ describe('Update runner id after adding(should fail)', () => {
    let added_runner;
    let added_runner_id;
    it('creating a new org with just a name should return 200', async () => {
-        const res1 = await axios.post(base + '/api/organisations', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        let added_org = res1.data
@@ -134,7 +135,7 @@ describe('Update runner group with invalid group after adding', () => {
    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', {
+        const res1 = await axios.post(base + '/api/organizations', {
            "name": "test123"
        }, axios_config);
        added_org = res1.data
--- a/src/tests/scans/scans_add.spec.ts
+++ b/src/tests/scans/scans_add.spec.ts
@@ -19,7 +19,7 @@ describe('POST /api/scans illegally', () => {
 	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', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
@@ -70,7 +70,7 @@ describe('POST /api/scans successfully', () => {
 	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', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
@@ -144,7 +144,7 @@ describe('POST /api/scans successfully via scan station', () => {
 	let added_track;
 	let added_station;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
--- a/src/tests/scans/scans_delete.spec.ts
+++ b/src/tests/scans/scans_delete.spec.ts
@@ -21,7 +21,7 @@ describe('DELETE scan', () => {
 	let added_runner;
 	let added_scan;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
--- a/src/tests/scans/scans_get.spec.ts
+++ b/src/tests/scans/scans_get.spec.ts
@@ -35,7 +35,7 @@ describe('adding + getting scans', () => {
 	let added_runner;
 	let added_scan;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
@@ -61,9 +61,17 @@ describe('adding + getting scans', () => {
 		expect(res.status).toEqual(200);
 		expect(res.headers['content-type']).toContain("application/json")
 	});
-	it('check if scans was added (no parameter validation)', async () => {
+	it('check if scans was added directly', async () => {
 		const res = await axios.get(base + '/api/scans/' + added_scan.id, axios_config);
 		expect(res.status).toEqual(200);
 		expect(res.headers['content-type']).toContain("application/json");
+		expect(res.data).toEqual(added_scan);
+	});
+	it('check if scans was added via the runner/scans endpoint.', async () => {
+		const res = await axios.get(base + '/api/runners/' + added_runner.id + "/scans", axios_config);
+		expect(res.status).toEqual(200);
+		expect(res.headers['content-type']).toContain("application/json");
+		added_scan.runner.distance = 0;
+		expect(res.data).toContainEqual(added_scan);
 	});
 });
--- a/src/tests/scans/scans_update.spec.ts
+++ b/src/tests/scans/scans_update.spec.ts
@@ -19,7 +19,7 @@ describe('adding + updating illegally', () => {
 	let added_runner;
 	let added_scan;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
@@ -86,7 +86,7 @@ describe('adding + updating successfilly', () => {
 	let added_runner2;
 	let added_scan;
 	it('creating a new org with just a name should return 200', async () => {
-		const res1 = await axios.post(base + '/api/organisations', {
+		const res1 = await axios.post(base + '/api/organizations', {
 			"name": "test123"
 		}, axios_config);
 		added_org = res1.data
--- a/src/tests/selfservice/selfservice_get.spec.ts
+++ b/src/tests/selfservice/selfservice_get.spec.ts
@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { config } from '../../config';
+const base = "http://localhost:" + config.internal_port
+
+let access_token;
+let axios_config;
+
+beforeAll(async () => {
+    const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
+    access_token = res.data["access_token"];
+    axios_config = {
+        headers: { "authorization": "Bearer " + access_token },
+        validateStatus: undefined
+    };
+});
+
+describe('GET /api/runners/me invalid should return fail', () => {
+    it('get with invalid jwt should return 401', async () => {
+        const res = await axios.get(base + '/api/runners/me/123.123', axios_config);
+        expect(res.status).toEqual(401);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+});
+// ---------------
+describe('register + get should return 200', () => {
+    let added_runner;
+    it('registering as citizen should return 200', async () => {
+        const res = await axios.post(base + '/api/runners/register', {
+            "firstname": "string",
+            "middlename": "string",
+            "lastname": "string",
+            "email": "user@example.com"
+        }, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+        added_runner = res.data;
+    });
+    it('get with valid jwt should return 200', async () => {
+        const res = await axios.get(base + '/api/runners/me/' + added_runner.token, axios_config);
+        expect(res.status).toEqual(200);
+        expect(res.headers['content-type']).toContain("application/json");
+    });
+});
--- a/Show More
+++ b/Show More