Merge branch 'dev' into feature/13-runner_controllers

ref #13 #17

src/controllers/RunnerController.ts

@@ -1,11 +1,12 @@
 import { 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 { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { RunnerGroupNeededError, RunnerIdsNotMatchingError, RunnerNotFoundError } from '../errors/RunnerErrors';
 import { RunnerGroupNotFoundError } from '../errors/RunnerGroupErrors';
 import { CreateRunner } from '../models/actions/CreateRunner';
 import { Runner } from '../models/entities/Runner';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseRunner } from '../models/responses/ResponseRunner';
 
 @JsonController('/runners')
@@ -83,10 +84,12 @@ export class RunnerController {
 
 	@Delete('/:id')
 	@ResponseSchema(ResponseRunner)
-	@ResponseSchema(RunnerNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete a specified runner (if it exists).' })
-	async remove(@EntityFromParam('id') runner: Runner, @QueryParam("force") force: boolean) {
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
-		if (!runner) { throw new RunnerNotFoundError(); }
+		let runner = await this.runnerRepository.findOne({ id: id });
+		if (!runner) { return null; }
 		const responseRunner = await this.runnerRepository.findOne(runner, { relations: ['scans', 'group'] });
 
 		if (!runner) {

src/controllers/RunnerOrganisationController.ts

@@ -1,10 +1,11 @@
 import { 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 { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { RunnerOrganisationHasRunnersError, RunnerOrganisationHasTeamsError, RunnerOrganisationIdsNotMatchingError, RunnerOrganisationNotFoundError } from '../errors/RunnerOrganisationErrors';
 import { CreateRunnerOrganisation } from '../models/actions/CreateRunnerOrganisation';
 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';
@@ -86,12 +87,14 @@ export class RunnerOrganisationController {
 
 	@Delete('/:id')
 	@ResponseSchema(ResponseRunnerOrganisation)
-	@ResponseSchema(RunnerOrganisationNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@ResponseSchema(RunnerOrganisationHasTeamsError, { statusCode: 406 })
 	@ResponseSchema(RunnerOrganisationHasRunnersError, { statusCode: 406 })
+	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete a specified runnerOrganisation (if it exists).' })
-	async remove(@EntityFromParam('id') organisation: RunnerOrganisation, @QueryParam("force") force: boolean) {
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
-		if (!organisation) { throw new RunnerOrganisationNotFoundError() }
+		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) {
@@ -101,7 +104,7 @@ export class RunnerOrganisationController {
 		}
 		const teamController = new RunnerTeamController()
 		for (let team of runnerOrganisation.teams) {
-			await teamController.remove(team, true);
+			await teamController.remove(team.id, true);
 		}
 
 		if (!force) {
@@ -111,7 +114,7 @@ export class RunnerOrganisationController {
 		}
 		const runnerController = new RunnerController()
 		for (let runner of runnerOrganisation.runners) {
-			await runnerController.remove(runner, true);
+			await runnerController.remove(runner.id, true);
 		}
 
 		const responseOrganisation = new ResponseRunnerOrganisation(runnerOrganisation);

src/controllers/RunnerTeamController.ts

@@ -1,10 +1,11 @@
 import { 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 { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { RunnerTeamHasRunnersError, RunnerTeamIdsNotMatchingError, RunnerTeamNotFoundError } from '../errors/RunnerTeamErrors';
 import { CreateRunnerTeam } from '../models/actions/CreateRunnerTeam';
 import { RunnerTeam } from '../models/entities/RunnerTeam';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseRunnerTeam } from '../models/responses/ResponseRunnerTeam';
 import { RunnerController } from './RunnerController';
 
@@ -86,11 +87,13 @@ export class RunnerTeamController {
 
 	@Delete('/:id')
 	@ResponseSchema(ResponseRunnerTeam)
-	@ResponseSchema(RunnerTeamNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
 	@ResponseSchema(RunnerTeamHasRunnersError, { statusCode: 406 })
+	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete a specified runnerTeam (if it exists).' })
-	async remove(@EntityFromParam('id') team: RunnerTeam, @QueryParam("force") force: boolean) {
+	async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
-		if (!team) { throw new RunnerTeamNotFoundError(); }
+		let team = await this.runnerTeamRepository.findOne({ id: id });
+		if (!team) { return null; }
 		let runnerTeam = await this.runnerTeamRepository.findOne(team, { relations: ['parentGroup', 'contact', 'runners'] });
 
 		if (!force) {
@@ -100,7 +103,7 @@ export class RunnerTeamController {
 		}
 		const runnerController = new RunnerController()
 		for (let runner of runnerTeam.runners) {
-			await runnerController.remove(runner, true);
+			await runnerController.remove(runner.id, true);
 		}
 
 		const responseTeam = new ResponseRunnerTeam(runnerTeam);

src/controllers/TrackController.ts

@@ -1,10 +1,11 @@
 import { Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { TrackIdsNotMatchingError, TrackNotFoundError } from "../errors/TrackErrors";
 import { CreateTrack } from '../models/actions/CreateTrack';
 import { Track } from '../models/entities/Track';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 import { ResponseTrack } from '../models/responses/ResponseTrack';
 
 @JsonController('/tracks')
@@ -74,10 +75,12 @@ export class TrackController {
 
 	@Delete('/:id')
 	@ResponseSchema(ResponseTrack)
-	@ResponseSchema(TrackNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
 	@OpenAPI({ description: "Delete a specified track (if it exists)." })
-	async remove(@EntityFromParam('id') track: Track) {
+	async remove(@Param("id") id: number) {
-		if (!track) { throw new TrackNotFoundError(); }
+		let track = await this.trackRepository.findOne({ id: id });
+		if (!track) { return null; }
 
 		await this.trackRepository.delete(track);
 		return new ResponseTrack(track);

src/controllers/UserController.ts

@@ -1,11 +1,12 @@
 import { Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { UserIdsNotMatchingError, UserNotFoundError } from '../errors/UserErrors';
 import { UserGroupNotFoundError } from '../errors/UserGroupErrors';
 import { CreateUser } from '../models/actions/CreateUser';
 import { User } from '../models/entities/User';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 
 
 @JsonController('/users')
@@ -72,11 +73,13 @@ export class UserController {
 
 	@Delete('/:id')
 	@ResponseSchema(User)
-	@ResponseSchema(UserNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete a specified runner (if it exists).' })
-	async remove(@EntityFromParam('id') user: User) {
+	async remove(@Param("id") id: number) {
+		let user = await this.userRepository.findOne({ id: id });
 		if (!user) {
-			throw new UserNotFoundError();
+			return null;
 		}
 
 		await this.userRepository.delete(user);

src/controllers/UserGroupController.ts

@@ -1,10 +1,11 @@
 import { Body, Delete, Get, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers';
 import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
 import { getConnectionManager, Repository } from 'typeorm';
-import { EntityFromBody, EntityFromParam } from 'typeorm-routing-controllers-extensions';
+import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
 import { UserGroupIdsNotMatchingError, UserGroupNotFoundError } from '../errors/UserGroupErrors';
 import { CreateUserGroup } from '../models/actions/CreateUserGroup';
 import { UserGroup } from '../models/entities/UserGroup';
+import { ResponseEmpty } from '../models/responses/ResponseEmpty';
 
 
 @JsonController('/usergroups')
@@ -71,11 +72,13 @@ export class UserGroupController {
 
 	@Delete('/:id')
 	@ResponseSchema(UserGroup)
-	@ResponseSchema(UserGroupNotFoundError, { statusCode: 404 })
+	@ResponseSchema(ResponseEmpty, { statusCode: 204 })
+	@OnUndefined(204)
 	@OpenAPI({ description: 'Delete a specified usergroup (if it exists).' })
-	async remove(@EntityFromParam('id') group: UserGroup) {
+	async remove(@Param("id") id: number) {
+		let group = await this.userGroupsRepository.findOne({ id: id });
 		if (!group) {
-			throw new UserGroupNotFoundError();
+			return null;
 		}
 
 		await this.userGroupsRepository.delete(group);

src/models/responses/ResponseEmpty.ts

@@ -0,0 +1,6 @@
+
+/**
+ * Defines a empty response object
+*/
+export class ResponseEmpty {
+}