diff --git a/.gitignore b/.gitignore
index 9db3cfb0b35c9ac31228ab865721650dd0e9512f..a31d6a524eab9912473012be6b823a3416fbbf94 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,3 +36,7 @@ lerna-debug.log*
# db connection
.env
*.providers.ts
+
+# uploads
+images/*
+!images/default.jpeg
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index e197579511b72d74b03e46cad79a6c3369014b06..f5a573ea003752d767736d4a37a1b7f99f9dbdb7 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -34,7 +34,7 @@ e2e-testing:
- docker-compose build --no-cache
- docker-compose up -d
after_script:
- - sleep 8
+ - sleep 3
- echo "create database ehasa;" | docker exec -i postgis psql -U postgres
- echo "create user ehasa;" | docker exec -i postgis psql -U postgres
- echo "alter user ehasa with encrypted password 'salasana';" | docker exec -i postgis psql -U postgres
diff --git a/images/default.jpeg b/images/default.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..7e5e656834bfa61b0fc135c94d1fb9089596f2f6
Binary files /dev/null and b/images/default.jpeg differ
diff --git a/package-lock.json b/package-lock.json
index be2f7c8964168262bdeaafcfad35ef0656a2656e..01d2eb7272357854133cd7fe3325d9234a86c4cb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -426,11 +426,11 @@
}
},
"@nestjs/common": {
- "version": "6.2.4",
- "resolved": "https://registry.npmjs.org/@nestjs/common/-/common-6.2.4.tgz",
- "integrity": "sha512-YZvJ6/S7yVQZK+9rupCzMCg4tpbc9DyVvLoTx0NBDqExTCUNcNEcCtn0AZrO/hLqbeYODnJwGE2NxkH1R/qw+w==",
+ "version": "6.5.2",
+ "resolved": "https://registry.npmjs.org/@nestjs/common/-/common-6.5.2.tgz",
+ "integrity": "sha512-vkB6JLPPckjS35usLMV3Q6vljkgzhN3jgQ+U1VY6cKriyjnkIcUKo37tNQSPYkaAGe1pOLK4IkmwMTSyhNieyg==",
"requires": {
- "axios": "0.18.0",
+ "axios": "0.19.0",
"cli-color": "1.4.0",
"uuid": "3.3.2"
}
@@ -1272,12 +1272,19 @@
"dev": true
},
"axios": {
- "version": "0.18.0",
- "resolved": "https://registry.npmjs.org/axios/-/axios-0.18.0.tgz",
- "integrity": "sha1-MtU+SFHv3AoRmTts0AB4nXDAUQI=",
+ "version": "0.19.0",
+ "resolved": "https://registry.npmjs.org/axios/-/axios-0.19.0.tgz",
+ "integrity": "sha512-1uvKqKQta3KBxIz14F2v06AEHZ/dIoeKfbTRkK1E5oqjDnuEerLmYTgJB5AiQZHJcljpg1TuRzdjDR06qNk0DQ==",
"requires": {
- "follow-redirects": "^1.3.0",
- "is-buffer": "^1.1.5"
+ "follow-redirects": "1.5.10",
+ "is-buffer": "^2.0.2"
+ },
+ "dependencies": {
+ "is-buffer": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.3.tgz",
+ "integrity": "sha512-U15Q7MXTuZlrbymiz95PJpZxu8IlipAp4dtS3wOdgPXx3mqBnslrWU14kxfHB+Py/+2PVKSr37dMAgM2A4uArw=="
+ }
}
},
"babel-jest": {
@@ -2172,11 +2179,12 @@
}
},
"d": {
- "version": "1.0.0",
- "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz",
- "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=",
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz",
+ "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==",
"requires": {
- "es5-ext": "^0.10.9"
+ "es5-ext": "^0.10.50",
+ "type": "^1.0.1"
}
},
"dashdash": {
@@ -2222,6 +2230,7 @@
"version": "3.2.6",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
"integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+ "dev": true,
"requires": {
"ms": "^2.1.1"
}
@@ -2598,13 +2607,13 @@
}
},
"es6-weak-map": {
- "version": "2.0.2",
- "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.2.tgz",
- "integrity": "sha1-XjqzIlH/0VOKH45f+hNXdy+S2W8=",
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz",
+ "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==",
"requires": {
"d": "1",
- "es5-ext": "^0.10.14",
- "es6-iterator": "^2.0.1",
+ "es5-ext": "^0.10.46",
+ "es6-iterator": "^2.0.3",
"es6-symbol": "^3.1.1"
}
},
@@ -2819,11 +2828,6 @@
}
}
},
- "express-rate-limit": {
- "version": "4.0.4",
- "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-4.0.4.tgz",
- "integrity": "sha512-DLRj2vMO7Xgai8qWKU9O6ZztF2bdDmfFNFi9k3G9BPzJ+7MG7eWaaBikbe0eBpNGSxU8JziwW0PQKG78aNWa6g=="
- },
"extend": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
@@ -3026,11 +3030,26 @@
}
},
"follow-redirects": {
- "version": "1.7.0",
- "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.7.0.tgz",
- "integrity": "sha512-m/pZQy4Gj287eNy94nivy5wchN3Kp+Q5WgUPNy5lJSZ3sgkVKSYV/ZChMAQVIgx1SqfZ2zBZtPA2YlXIWxxJOQ==",
+ "version": "1.5.10",
+ "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.5.10.tgz",
+ "integrity": "sha512-0V5l4Cizzvqt5D44aTXbFZz+FtyXV1vrDN6qrelxtfYQKW0KO0W2T/hkE8xvGa/540LkZlkaUjO4ailYTFtHVQ==",
"requires": {
- "debug": "^3.2.6"
+ "debug": "=3.1.0"
+ },
+ "dependencies": {
+ "debug": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
+ "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
+ "requires": {
+ "ms": "2.0.0"
+ }
+ },
+ "ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+ }
}
},
"for-in": {
@@ -4048,7 +4067,8 @@
"is-buffer": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
- "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w=="
+ "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+ "dev": true
},
"is-callable": {
"version": "1.1.4",
@@ -5095,9 +5115,9 @@
}
},
"lodash": {
- "version": "4.17.11",
- "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
- "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==",
+ "version": "4.17.14",
+ "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.14.tgz",
+ "integrity": "sha512-mmKYbW3GLuJeX+iGP+Y7Gp1AiGHGbXHCOh/jZmrawMmsE7MS4znI3RL2FsjbqOyMayHInjOeykW7PEajUk1/xw==",
"dev": true
},
"lodash.includes": {
@@ -5368,9 +5388,9 @@
"integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0="
},
"mixin-deep": {
- "version": "1.3.1",
- "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.1.tgz",
- "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==",
+ "version": "1.3.2",
+ "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
+ "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==",
"dev": true,
"requires": {
"for-in": "^1.0.2",
@@ -6638,9 +6658,9 @@
"integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc="
},
"set-value": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz",
- "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==",
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz",
+ "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
"dev": true,
"requires": {
"extend-shallow": "^2.0.1",
@@ -7627,6 +7647,11 @@
"integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=",
"dev": true
},
+ "type": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/type/-/type-1.0.1.tgz",
+ "integrity": "sha512-MAM5dBMJCJNKs9E7JXo4CXRAansRfG0nlJxW7Wf6GZzSOvH31zClSaHdIMWLehe/EGMBkqeC55rrkaOr5Oo7Nw=="
+ },
"type-check": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
@@ -7824,38 +7849,15 @@
"integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg=="
},
"union-value": {
- "version": "1.0.0",
- "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz",
- "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=",
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz",
+ "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==",
"dev": true,
"requires": {
"arr-union": "^3.1.0",
"get-value": "^2.0.6",
"is-extendable": "^0.1.1",
- "set-value": "^0.4.3"
- },
- "dependencies": {
- "extend-shallow": {
- "version": "2.0.1",
- "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
- "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
- "dev": true,
- "requires": {
- "is-extendable": "^0.1.0"
- }
- },
- "set-value": {
- "version": "0.4.3",
- "resolved": "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz",
- "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=",
- "dev": true,
- "requires": {
- "extend-shallow": "^2.0.1",
- "is-extendable": "^0.1.1",
- "is-plain-object": "^2.0.1",
- "to-object-path": "^0.3.0"
- }
- }
+ "set-value": "^2.0.1"
}
},
"unique-string": {
diff --git a/package.json b/package.json
index 794db7d353397154ef795d59135b5771df8300ff..3677b2a8db9be496cadc813cab1446501627bbc3 100644
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
"test:e2e": "jest --config ./test/jest-e2e.json"
},
"dependencies": {
- "@nestjs/common": "^6.0.0",
+ "@nestjs/common": "^6.5.2",
"@nestjs/core": "^6.0.0",
"@nestjs/jwt": "^6.1.1",
"@nestjs/platform-express": "^6.0.0",
@@ -30,7 +30,6 @@
"bcryptjs": "^2.4.3",
"class-transformer": "^0.2.3",
"class-validator": "^0.9.1",
- "express-rate-limit": "^4.0.4",
"jsonwebtoken": "^8.5.1",
"passport-jwt": "^4.0.0",
"pg": "^7.11.0",
diff --git a/src/app.controller.ts b/src/app.controller.ts
index cce879ee622146012901c9adb47ef40c0fd3a555..045e5b1ae398cd994ada21cd7f9512b475af30ec 100644
--- a/src/app.controller.ts
+++ b/src/app.controller.ts
@@ -1,4 +1,4 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, Param, Res } from '@nestjs/common';
import { AppService } from './app.service';
@Controller()
@@ -9,4 +9,9 @@ export class AppController {
getHello(): string {
return this.appService.getHello();
}
+
+ @Get('images/:id')
+ returnImage(@Param('id') id, @Res() res) {
+ return;
+ }
}
diff --git a/src/app.module.ts b/src/app.module.ts
index f2c7b7765304436488bbadb3fdfce4fbdc1fbd9a..05685cd88382fd6e6e29caadfbab83b0c658d953 100644
--- a/src/app.module.ts
+++ b/src/app.module.ts
@@ -2,15 +2,12 @@ import { Module } from '@nestjs/common';
import { APP_FILTER, APP_INTERCEPTOR, APP_GUARD } from '@nestjs/core';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Connection } from 'typeorm';
-
import { AppController } from './app.controller';
import { AppService } from './app.service';
-
import { RolesGuard } from './shared/roles.guard';
-import { LoggingInterceptor } from './shared/logging.interceptor';
+//import { LoggingInterceptor } from './shared/logging.interceptor';
import { StatesGuard } from './shared/states.guard';
import { HttpErrorFilter } from './shared/http-error.filter';
-
import { NotificationModule } from './notifications/notifications.module';
import { TaskModule } from './task/task.module';
import { TrackingModule } from './tracking/tracking.module';
@@ -19,6 +16,28 @@ import { DrawModule } from './draw/draw.module';
import { FactionModule } from './faction/faction.module';
import { GameModule } from './game/game.module';
import { ScoreModule } from './score/score.module';
+import { ReplayModule } from './replay/replay.module';
+import { TickModule } from './tick/tick.module';
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// Core of the server, ///
+/// Every module is being imported and combined here. ///
+/// ///
+/// AppController needs to be kept in for SSL verification to work (root needs to return something) ///
+/// ///
+/// TypeOrmModule checks ormconfig.json for database connection. ///
+/// ///
+/// More information on global decorators can be found from shared folder. ///
+/// ///
+/// Providers can be found from shared folder ///
+/// - HttpErrorFilter ///
+/// - LoggingInterceptor ///
+/// - RolesGuard Decorator ///
+/// - StatesGuard Decorator ///
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
@Module({
imports: [
@@ -31,6 +50,8 @@ import { ScoreModule } from './score/score.module';
FactionModule,
TrackingModule,
ScoreModule,
+ ReplayModule,
+ TickModule,
],
controllers: [AppController],
providers: [
@@ -39,10 +60,7 @@ import { ScoreModule } from './score/score.module';
provide: APP_FILTER,
useClass: HttpErrorFilter,
},
- {
- provide: APP_INTERCEPTOR,
- useClass: LoggingInterceptor,
- },
+
{
provide: APP_GUARD,
useClass: RolesGuard,
diff --git a/src/draw/coordinate.entity.ts b/src/draw/coordinate.entity.ts
index ef5447f61cfd1dd07d1f81a8ee1fce8e8256da2a..da5e940a74b31a21479527b02b847aaeda9d950e 100644
--- a/src/draw/coordinate.entity.ts
+++ b/src/draw/coordinate.entity.ts
@@ -1,22 +1,22 @@
-import {
- Entity,
- Column,
- PrimaryGeneratedColumn,
- ManyToOne,
- Timestamp,
-} from 'typeorm';
+import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
-import { Game_PersonEntity, GameEntity } from '../game/game.entity';
+import { GameEntity } from '../game/game.entity';
import { FactionEntity } from '../faction/faction.entity';
+///////////////////////////////////////////////////////////////////////////
+/// MapDrawingEntity & MapDrawingHistoryEntity reflect database tables. ///
+/// ///
+/// MapDrawing ownershipCheck checks users rights to MapDrawing ///
+///////////////////////////////////////////////////////////////////////////
+
@Entity('MapDrawing')
export class MapDrawingEntity {
@PrimaryGeneratedColumn('uuid') mapDrawingId: string;
@Column({ type: 'bool', nullable: true }) drawingIsActive: boolean;
- @Column({ type: 'time', nullable: true }) drawingValidTill: string;
-
@Column({ type: 'json', nullable: true }) data: JSON;
+ // When Faction or game that has the drawing in question is deleted from
+ // the database, the drawing is also deleted
@ManyToOne(type => FactionEntity, faction => faction.mapDrawings, {
onDelete: 'CASCADE',
})
@@ -25,27 +25,28 @@ export class MapDrawingEntity {
onDelete: 'CASCADE',
})
gameId: GameEntity;
+
+ async ownershipCheck(factionEntity, role) {
+ if (role === 'admin') {
+ return factionEntity == this.faction;
+ } else {
+ return this.faction && factionEntity.factionId === this.faction.factionId
+ ? true
+ : false;
+ }
+ }
}
-@Entity('Game_Person_MapDrawing')
-export class Game_Person_MapDrawingEntity {
- @PrimaryGeneratedColumn('uuid') GPmapDrawingId: string;
- @Column({ type: 'timestamp' }) GPCTimeStamp: Timestamp;
+@Entity('MapDrawingHistory')
+export class MapDrawingHistoryEntity {
+ @PrimaryGeneratedColumn('uuid') mapDrawingHistoryId: string;
+ @Column('float') timestamp: number;
+ @Column('bool') drawingIsActive: boolean;
+ @Column('json') data: JSON;
- @ManyToOne(
- type => Game_PersonEntity,
- game_person => game_person.gamepersonId,
- {
- onDelete: 'CASCADE',
- },
- )
- game_person: Game_PersonEntity;
- @ManyToOne(
- type => MapDrawingEntity,
- map_drawing => map_drawing.mapDrawingId,
- {
- onDelete: 'CASCADE',
- },
- )
- map_drawing: MapDrawingEntity;
+ // If drawing is deleted, it's histories are deleted also
+ @ManyToOne(() => MapDrawingEntity, mapDrawing => mapDrawing.mapDrawingId, {
+ onDelete: 'CASCADE',
+ })
+ mapdrawing: string;
}
diff --git a/src/draw/draw.controller.ts b/src/draw/draw.controller.ts
index 26f6cf8c56142ef190ad3bcbfd7ce9d32caa371e..d66bebe1ffe091fcda211a64f2b4b49601dd75b1 100644
--- a/src/draw/draw.controller.ts
+++ b/src/draw/draw.controller.ts
@@ -1,42 +1,50 @@
import {
Controller,
Put,
- UseGuards,
Get,
Param,
UsePipes,
ValidationPipe,
Body,
+ UseInterceptors,
+ ClassSerializerInterceptor,
} from '@nestjs/common';
-import { AuthGuard } from '../shared/auth.guard';
import { DrawService } from './draw.service';
import { Roles, GameStates } from '../shared/guard.decorator';
-import { MapDrawingDTO, ReturnDrawingsDTO } from './mapdrawing.dto';
+import { MapDrawingDTO } from './mapdrawing.dto';
+import { GamePerson } from '../game/gameperson.decorator';
+
+//////////////////////////////////////////////////////////////////////////
+/// DrawController ///
+/// ///
+/// Functions either insert or return MapDrawing data, ///
+/// Insert functions require user to have proper role (either gm ///
+/// or commander) in the game to be able store the data: ///
+/// MapDrawingDTO data to database. ///
+/// Data return functions require atleast spectator role. ///
+//////////////////////////////////////////////////////////////////////////
-/*
- DrawController
-
- Functions either insert or return MapDrawing data,
- Insert functions require user to have proper role (either gm or commander) in the game to be able store the ddata: MapDrawingDTOata to database.
- Data return functions require atleast spectator role.
- */
@Controller('draw')
export class DrawController {
constructor(private drawService: DrawService) {}
@Put('mapdrawing/:id')
@Roles('admin', 'factionleader')
- @GameStates('CREATED', 'STARTED')
+ @GameStates('CREATED', 'STARTED', 'PAUSED')
@UsePipes(new ValidationPipe())
- async draw(@Param('id') gameId, @Body() data: MapDrawingDTO) {
- return this.drawService.draw(gameId, data);
+ async draw(
+ @GamePerson() gameperson,
+ @Param('id') gameId,
+ @Body() data: MapDrawingDTO,
+ ) {
+ return this.drawService.draw(gameperson, gameId, data);
}
@Get('map/:id')
- @UseGuards(new AuthGuard())
- @UsePipes(new ValidationPipe())
- async drawMap(@Param('id') id, @Body() data: ReturnDrawingsDTO) {
- return this.drawService.drawMap(id, data);
+ @Roles('admin', 'factionleader', 'soldier', 'groupleader')
+ @UseInterceptors(ClassSerializerInterceptor)
+ async drawMap(@GamePerson() gameperson, @Param('id') gameId) {
+ return this.drawService.drawMap(gameperson, gameId);
}
}
diff --git a/src/draw/draw.module.ts b/src/draw/draw.module.ts
index a56cbbbb7fb49b476842177a4a0a9e7e0b592b3c..f03fc3acf1657620259eab31621c81f72ded7d46 100644
--- a/src/draw/draw.module.ts
+++ b/src/draw/draw.module.ts
@@ -3,20 +3,28 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { DrawController } from './draw.controller';
import { DrawService } from './draw.service';
-import { MapDrawingEntity } from '../draw/coordinate.entity';
+import {
+ MapDrawingEntity,
+ MapDrawingHistoryEntity,
+} from '../draw/coordinate.entity';
import { FactionEntity } from '../faction/faction.entity';
import { Game_PersonEntity } from '../game/game.entity';
-/*
-Draw
-- contains everything to do with mapdrawing data.
-*/
+import { NotificationModule } from 'src/notifications/notifications.module';
+
+/////////////////////////////////////////////////////////////////////
+/// Draw ///
+/// - contains everything to do with mapdrawing data. ///
+/////////////////////////////////////////////////////////////////////
+
@Module({
imports: [
TypeOrmModule.forFeature([
MapDrawingEntity,
+ MapDrawingHistoryEntity,
FactionEntity,
Game_PersonEntity,
]),
+ NotificationModule,
],
controllers: [DrawController],
providers: [DrawService],
diff --git a/src/draw/draw.service.ts b/src/draw/draw.service.ts
index d5ddf23e9574771bc769e2b6d58b59a4e95ad10d..da4b239dd5ef98c1572b5e64ff52525cd9f16e38 100644
--- a/src/draw/draw.service.ts
+++ b/src/draw/draw.service.ts
@@ -1,46 +1,99 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
-import { MapDrawingEntity } from '../draw/coordinate.entity';
-import { MapDrawingDTO, ReturnDrawingsDTO } from './mapdrawing.dto';
+import {
+ MapDrawingEntity,
+ MapDrawingHistoryEntity,
+} from '../draw/coordinate.entity';
+import { MapDrawingDTO } from './mapdrawing.dto';
+import { NotificationGateway } from '../notifications/notifications.gateway';
+
+///////////////////////////////////////////////////////////////////////////
+/// DrawService contains handling of MapDrawings and MapDrawinghistory ///
+///////////////////////////////////////////////////////////////////////////
@Injectable()
export class DrawService {
constructor(
@InjectRepository(MapDrawingEntity)
private mapDrawingRepository: Repository<MapDrawingEntity>,
+ @InjectRepository(MapDrawingHistoryEntity)
+ private mapDrawHistoryRepository: Repository<MapDrawingHistoryEntity>,
+ private notificationGateway: NotificationGateway,
) {}
- async draw(gameId, data: MapDrawingDTO) {
+ async draw(gameperson, gameId, data: MapDrawingDTO) {
data['gameId'] = gameId;
const drawing = await this.mapDrawingRepository.create(data);
+ this.notificationGateway.server.emit(gameId, {
+ type: 'drawing-update',
+ });
+ // create new instance if id is null
if (data.mapDrawingId == null || data.mapDrawingId == '') {
- // luo uuden instanssin.
+ drawing.faction = gameperson.faction;
const mapDrawing = await this.mapDrawingRepository.insert(drawing);
+ // create a history entity and insert it
+ await this.createHistory(data, gameperson, mapDrawing);
return mapDrawing.identifiers;
- } else {
- //päivittää mapDrawingin
+ }
+ // get ref from db
+ const draw = await this.mapDrawingRepository.findOne({
+ where: { mapDrawingId: data.mapDrawingId },
+ relations: ['faction'],
+ });
+ if (await draw.ownershipCheck(gameperson.faction, gameperson.role)) {
+ // else update the existing instance
+ await this.createHistory(data, gameperson);
return await this.mapDrawingRepository.save(drawing);
}
+
+ throw new HttpException(
+ 'Drawing is not from your faction!',
+ HttpStatus.BAD_REQUEST,
+ );
}
- // draw map based on game and
- async drawMap(id, data: ReturnDrawingsDTO) {
+ // used to create mapDrawing history entity entry
+ private async createHistory(data, gameperson, mapDrawing?) {
+ // create a history entity and insert it
+ const history = await this.mapDrawHistoryRepository.create({
+ data: data.data,
+ drawingIsActive: data.drawingIsActive,
+ mapdrawing:
+ data.mapDrawingId || mapDrawing.identifiers[0]['mapDrawingId'],
+ timestamp: Date.now(),
+ });
+ history.data['faction'] = gameperson.faction
+ ? gameperson.faction.factionName
+ : 'admin';
+ await this.mapDrawHistoryRepository.insert(history);
+ }
+
+ // draw map based on game and gameperson faction
+ async drawMap(gameperson, gameId) {
+ // return all active drawings if admin
+ if (gameperson.role === 'admin') {
+ return await this.mapDrawingRepository.find({
+ where: { gameId: gameId, drawingIsActive: true },
+ relations: ['faction'],
+ });
+ }
// return mapdrawings with given faction and gameid
return await this.mapDrawingRepository.find({
where: [
{
- gameId: id,
- faction: data.factionId,
+ gameId: gameId,
+ faction: gameperson.faction,
drawingIsActive: true,
},
{
- gameId: id,
+ gameId: gameId,
faction: null,
drawingIsActive: true,
},
],
+ relations: ['faction'],
});
}
}
diff --git a/src/draw/mapdrawing.dto.ts b/src/draw/mapdrawing.dto.ts
index f7e7c781a0cbd308edf5f8c14f068b449f43a05e..f342dd2a924fb8718fce8c3f8097c7fc43fea26b 100644
--- a/src/draw/mapdrawing.dto.ts
+++ b/src/draw/mapdrawing.dto.ts
@@ -1,6 +1,5 @@
import { IsUUID, IsOptional, IsBoolean, Allow } from 'class-validator';
-import { FactionEntity } from '../faction/faction.entity';
import { GameEntity } from '../game/game.entity';
export class MapDrawingDTO {
@@ -12,16 +11,6 @@ export class MapDrawingDTO {
@IsOptional()
@IsUUID('4')
gameId: GameEntity;
- @IsOptional()
- @IsUUID('4')
- faction?: FactionEntity;
@IsBoolean()
drawingIsActive?: boolean;
- drawingValidTill?: string;
-}
-
-export class ReturnDrawingsDTO {
- @IsOptional()
- @IsUUID('4')
- factionId: FactionEntity;
}
diff --git a/src/faction/faction.controller.ts b/src/faction/faction.controller.ts
index da7e5950626bbcd5385d80755d208e59be589b48..5eb905cb17b45b451720b0a021bc2ed877ece4ac 100644
--- a/src/faction/faction.controller.ts
+++ b/src/faction/faction.controller.ts
@@ -7,8 +7,7 @@ import {
Body,
Get,
Put,
- UseInterceptors,
- ClassSerializerInterceptor,
+ Delete,
} from '@nestjs/common';
import { AuthGuard } from '../shared/auth.guard';
@@ -19,9 +18,28 @@ import {
PromotePlayerDTO,
JoinFactionDTO,
JoinGameGroupDTO,
+ FactionDTO,
} from './faction.dto';
import { FactionService } from './faction.service';
import { Roles, GameStates } from '../shared/guard.decorator';
+import { GamePerson } from '../game/gameperson.decorator';
+
+/////////////////////////////////////////////////////////////////////////////////
+/// FactionController is being used for routing: ///
+/// ///
+/// Group ///
+/// - create group when game status is CREATED ///
+/// - getting groups with faction id(this is used mainly for listing players) ///
+/// - joining group when game status is CREATED ///
+/// ///
+/// Faction ///
+/// - checking users faction ///
+/// - joining faction ///
+/// - leaving faction ///
+/// - changing faction multiplier (not implemented) ///
+/// ///
+/// See shared folder files for more information on decorators. ///
+/////////////////////////////////////////////////////////////////////////////////
@Controller('faction')
export class FactionController {
@@ -37,9 +55,7 @@ export class FactionController {
@Param('id') id: string,
@Body() data: GameGroupDTO,
) {
- try {
- return this.factionservice.createGroup(person, id, data);
- } catch (error) {}
+ return this.factionservice.createGroup(person, id, data);
}
// id is faction ID
@@ -53,17 +69,11 @@ export class FactionController {
@Roles('soldier')
@GameStates('CREATED')
async joinGroup(
- @User('id') person,
- @Param('id') id,
+ @GamePerson() gameperson,
+ @Param('id') gameId,
@Body() data: JoinGameGroupDTO,
) {
- return this.factionservice.joinGroup(person, id, data);
- }
-
- @UseInterceptors(ClassSerializerInterceptor)
- @Get('get-faction-members/:id')
- async getFactionMembers(@Param('id') factionId) {
- return this.factionservice.listFactionMembers(factionId);
+ return this.factionservice.joinGroup(gameperson, data);
}
// param game ID is passed to @Roles
@@ -79,7 +89,7 @@ export class FactionController {
// :id is the id of the game, and is needed for GameStates to check the state of the game
@Put('join-faction/:id')
@UseGuards(new AuthGuard())
- @GameStates('CREATED', 'STARTED')
+ @GameStates('CREATED', 'STARTED', 'PAUSED')
@UsePipes(new ValidationPipe())
joinFaction(
@User('id') person,
@@ -89,6 +99,24 @@ export class FactionController {
return this.factionservice.joinFaction(person, data);
}
+ // used to leave a faction
+ // :id is the if of the game
+ @Delete('leave/:id')
+ @Roles('soldier', 'factionleader')
+ @GameStates('CREATED')
+ leaveFaction(@GamePerson('gamepersonId') gamepersonId) {
+ return this.factionservice.leaveFaction(gamepersonId);
+ }
+
+ // used to change factions multiplier
+ // not implemented in frontend uncomment this and services equivalent when needed
+ // @Put('faction-multiplier/:id')
+ // @Roles('admin')
+ // @GameStates('STARTED')
+ // factionMultiplier(@Param('id') game, @Body() body: FactionDTO) {
+ // return this.factionservice.changeFactionMultiplier(body);
+ // }
+
// check if person belongs to a faction in a game
@Get('check-faction/:id')
@UseGuards(new AuthGuard())
diff --git a/src/faction/faction.dto.ts b/src/faction/faction.dto.ts
index 0b65c47007d6424584d8fdb35ac9d9ee53eaa924..511fce12d078c3c126641e62658540cbde7ae71b 100644
--- a/src/faction/faction.dto.ts
+++ b/src/faction/faction.dto.ts
@@ -8,13 +8,21 @@ import {
Min,
Max,
IsOptional,
+ IsHexColor,
+ IsIn,
} from 'class-validator';
import { GameEntity } from '../game/game.entity';
-import { RoleValidation, Uuid } from '../shared/custom-validation';
import { GameDTO } from '../game/game.dto';
import { FactionEntity, GameGroupEntity } from './faction.entity';
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// Contains Validation for FactionDTO, JoinFactionDTO, PromotePlayerDTO, GameGroupDTO, JoinGameGroupDTO ///
+/// ///
+/// uses class-validator built in validations ///
+/// see https://github.com/typestack/class-validator ///
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
export class FactionDTO {
@IsOptional()
@IsUUID('4')
@@ -23,6 +31,8 @@ export class FactionDTO {
@IsNotEmpty()
@Length(2, 31)
factionName: string;
+ @IsHexColor()
+ colour: string;
@IsString()
@IsNotEmpty()
@Length(3, 15)
@@ -46,7 +56,7 @@ export class JoinFactionDTO {
export class PromotePlayerDTO {
@IsUUID('4')
player: string;
- @Validate(RoleValidation)
+ @IsIn(['admin', 'soldier', 'factionleader'])
role: string;
}
@@ -54,6 +64,8 @@ export class GameGroupDTO {
@IsString()
@Length(3, 31)
name: string;
+ @IsIn(['infantry', 'recon', 'mechanized'])
+ class: string;
@IsUUID('4')
faction: FactionEntity;
}
diff --git a/src/faction/faction.entity.ts b/src/faction/faction.entity.ts
index 3aa74cf615d77deb1421d52d46d4159bf7e0d241..20b4a0a28b1d6eba7bd24cb0e0bad3fdd518bdcc 100644
--- a/src/faction/faction.entity.ts
+++ b/src/faction/faction.entity.ts
@@ -5,7 +5,6 @@ import {
OneToMany,
ManyToOne,
OneToOne,
- Timestamp,
JoinColumn,
} from 'typeorm';
@@ -13,80 +12,49 @@ import { GameEntity } from '../game/game.entity';
import { Game_PersonEntity } from '../game/game.entity';
import { MapDrawingEntity } from '../draw/coordinate.entity';
import { Exclude } from 'class-transformer';
+import { ScoreEntity } from '../score/score.entity';
-//Faction, PowerUp, Faction_powerUp, FP_History, Score
+///////////////////////////////////////////////////////////////////
+/// FactionEntity & GameGroupEntity reflect database tables. ///
+///////////////////////////////////////////////////////////////////
@Entity('Faction')
export class FactionEntity {
@PrimaryGeneratedColumn('uuid') factionId: string;
@Column('text') factionName: string;
@Column({ type: 'float' }) multiplier: number;
+ @Column('text') colour: string;
+ // Faction's password won't be included when FactionEntity is transformed
@Exclude()
@Column({ type: 'text' })
factionPassword: string;
@OneToMany(type => Game_PersonEntity, game_persons => game_persons.faction)
game_persons: Game_PersonEntity[];
+ // When Game where a Faction is in is deleted, the Factions in that game are also deleted
@ManyToOne(type => GameEntity, game => game.factions, {
onDelete: 'CASCADE',
})
game: GameEntity;
@OneToMany(type => MapDrawingEntity, mapDrawings => mapDrawings.faction)
mapDrawings: MapDrawingEntity[];
-
- factionObject() {
- const { factionId, factionName, game } = this;
- return { factionId, factionName, game };
- }
+ @OneToMany(type => ScoreEntity, score => score.scoreId, {
+ onDelete: 'NO ACTION',
+ })
+ scores: ScoreEntity[];
passwordCheck(pass: string) {
return pass == this.factionPassword ? true : false;
}
}
-/* @Entity('PowerUp')
-export class PowerUpEntity {
- @PrimaryGeneratedColumn('uuid') powerUpId: string;
- @Column({ type: 'text' }) powerUpName: string;
- @Column({ type: 'text' }) powerUpDescription: string;
- @Column({ type: 'int' }) amount: number;
- @Column({ type: 'time' }) cooldown: string;
-
- @OneToMany(type => FactionEntity, factions => factions.factionId, {
- onDelete: 'CASCADE',
- })
- factions: Faction_PowerUpEntity[];
-}
-
-@Entity('Faction_PowerUp')
-export class Faction_PowerUpEntity {
- @PrimaryGeneratedColumn('uuid') faction_powerUpId: string;
-
- @ManyToOne(type => FactionEntity, faction => faction.factionId)
- faction: FactionEntity;
- @ManyToOne(type => PowerUpEntity, powerUp => powerUp.factions)
- powerUp: PowerUpEntity;
- @OneToMany(type => FP_HistoryEntity, histories => histories.faction_PowerUp)
- histories: FP_HistoryEntity[];
-}
-
-@Entity('FP_History')
-export class FP_HistoryEntity {
- @PrimaryGeneratedColumn('uuid') historyId: string;
- @Column({ type: 'timestamp' }) historyTimeStamp: Timestamp;
-
- @ManyToOne(
- type => Faction_PowerUpEntity,
- faction_PowerUp => faction_PowerUp.histories,
- )
- faction_PowerUp: Faction_PowerUpEntity;
-} */
-
@Entity('GameGroup')
export class GameGroupEntity {
@PrimaryGeneratedColumn('uuid') id: string;
@Column('text') name: string;
+ @Column('text') class: string;
+ // When Groups leader, players or Faction is deleted, the Group(s) go also
@OneToOne(type => Game_PersonEntity, person => person.leaderGroup, {
onDelete: 'CASCADE',
})
diff --git a/src/faction/faction.module.ts b/src/faction/faction.module.ts
index dcb399aa1119851781270477c448ecec7362c804..3a3026da3695e79a7e375ea963cceee3360e048f 100644
--- a/src/faction/faction.module.ts
+++ b/src/faction/faction.module.ts
@@ -6,6 +6,19 @@ import { FactionService } from './faction.service';
import { GameGroupEntity, FactionEntity } from './faction.entity';
import { Game_PersonEntity } from '../game/game.entity';
+/////////////////////////////
+/// Entities ///
+/// - FactionEntity ///
+/// - Game_PersonEntity ///
+/// - GameGroupEntity ///
+/// ///
+/// Controllers ///
+/// - FactionController ///
+/// ///
+/// Provider ///
+/// - FactionService ///
+/////////////////////////////
+
@Module({
imports: [
TypeOrmModule.forFeature([
diff --git a/src/faction/faction.service.ts b/src/faction/faction.service.ts
index 67edef1db5d071e1936aba03ded5c5051c1ae713..9447c36777b01762a697bf75b38c36d14b34b4b8 100644
--- a/src/faction/faction.service.ts
+++ b/src/faction/faction.service.ts
@@ -3,9 +3,29 @@ import { InjectRepository } from '@nestjs/typeorm';
import { Repository, Not } from 'typeorm';
import { FactionEntity, GameGroupEntity } from './faction.entity';
-import { JoinFactionDTO, GameGroupDTO, JoinGameGroupDTO } from './faction.dto';
+import {
+ JoinFactionDTO,
+ GameGroupDTO,
+ JoinGameGroupDTO,
+ FactionDTO,
+} from './faction.dto';
import { Game_PersonEntity } from '../game/game.entity';
+///////////////////////////////////////////////////////
+/// FactionService contains functions for ///
+/// - Joining faction ///
+/// - Leaving faction ///
+/// - Change faction multiplier (not implemented) ///
+/// ///
+/// Group ///
+/// - Creating group ///
+/// - List faction players in groups ///
+/// ///
+/// Player ///
+/// - Promote player ///
+/// - verifying user ///
+///////////////////////////////////////////////////////
+
@Injectable()
export class FactionService {
constructor(
@@ -53,6 +73,23 @@ export class FactionService {
}
}
+ // removes entry from gameperson
+ async leaveFaction(gamepersonId) {
+ await this.game_PersonRepository.delete({ gamepersonId });
+ return {
+ message: 'leaved faction',
+ };
+ }
+
+ // changes factions multiplier to the value given to FactionDTO
+ // async changeFactionMultiplier(body: FactionDTO) {
+ // const faction = await this.factionRepository.findOne({
+ // where: { factionId: body.factionId },
+ // });
+ // faction.multiplier = body.multiplier;
+ // return await this.factionRepository.save(faction);
+ // }
+
async promotePlayer(body) {
const gamepersonId = body.player;
// get playerdata
@@ -60,9 +97,15 @@ export class FactionService {
where: { gamepersonId },
});
if (gameperson) {
- const factionleader = await this.game_PersonRepository.create(gameperson);
- factionleader.role = body.role;
- return await this.game_PersonRepository.save(factionleader);
+ const promotedPlayer = await this.game_PersonRepository.create(
+ gameperson,
+ );
+ promotedPlayer.role = body.role;
+ if (body.role === 'admin') {
+ promotedPlayer.faction = null;
+ promotedPlayer.group = null;
+ }
+ return await this.game_PersonRepository.save(promotedPlayer);
}
throw new HttpException('player does not exist', HttpStatus.BAD_REQUEST);
}
@@ -75,12 +118,11 @@ export class FactionService {
game: gameId,
});
// check if the authenticated person already belongs to a group
- if (
- await this.game_PersonRepository.findOne({
- group: Not(null),
- person: person,
- })
- ) {
+ let check = await this.game_PersonRepository.findOne({
+ where: { person: person, game: gameId },
+ relations: ['group'],
+ });
+ if (check.group) {
throw new HttpException(
'You already belong to a group!',
HttpStatus.BAD_REQUEST,
@@ -103,47 +145,92 @@ export class FactionService {
};
}
+ // get the groups in the given Faction
async showGroups(factionId) {
- return await this.game_GroupRepository.find({
- relations: ['leader', 'players'],
+ let players = await this.game_PersonRepository.find({
where: { faction: factionId },
+ relations: ['person', 'group'],
});
- }
- async joinGroup(person, gameId, data: JoinGameGroupDTO) {
- const gamePerson = await this.game_PersonRepository.findOne({
- person: person,
- game: gameId,
+ players.sort(function(a, b) {
+ return a.person.name.localeCompare(b.person.name);
});
- gamePerson.group = data.groupId;
- await this.game_PersonRepository.save(gamePerson);
- return {
- message: 'Joined group',
- };
- }
- async listFactionMembers(faction) {
- const members = await this.game_PersonRepository.find({
- where: { faction },
- relations: ['person'],
+ let groups = await this.game_GroupRepository.find({
+ where: { faction: factionId },
+ relations: ['leader', 'leader.person'],
});
- members.sort(function(a, b) {
- return a['person']['name'].localeCompare(b['person']['name']);
+
+ let resObj = await Promise.all(
+ groups.map(async group => {
+ return await {
+ id: group.id,
+ name: group.name,
+ class: group.class,
+ leader: group.leader.person.name,
+ players: [],
+ };
+ }),
+ );
+
+ resObj.push({
+ id: 'empty-group-id',
+ name: 'No group',
+ class: 'infantry',
+ leader: '',
+ players: [],
});
- return members;
+
+ await Promise.all(
+ players.map(async player => {
+ for (let i = 0; i < resObj.length; i++) {
+ if (player.group == null) {
+ resObj[resObj.length - 1].players.push({
+ gamepersonId: player.gamepersonId,
+ role: player.role,
+ name: player.person.name,
+ });
+ break;
+ }
+ if (resObj[i].name == player.group.name) {
+ resObj[i].players.push({
+ gamepersonId: player.gamepersonId,
+ role: player.role,
+ name: player.person.name,
+ });
+ break;
+ }
+ }
+ }),
+ );
+
+ return resObj;
}
+ // puts a non admin or faction leader player into a specified group
+ async joinGroup(gameperson, data: JoinGameGroupDTO) {
+ gameperson.group = data.groupId;
+ await this.game_PersonRepository.save(gameperson);
+ return {
+ message: 'Joined group',
+ };
+ }
+
+ // checks if player is in a faction and what role the player is in
async verifyUser(person, game) {
const gameperson = await this.game_PersonRepository.findOne({
where: { person, game },
- relations: ['faction'],
+ relations: ['faction', 'group'],
});
- if (gameperson) {
+ if (gameperson && gameperson.faction) {
return {
- message: gameperson,
+ factionId: gameperson.faction.factionId,
+ factionName: gameperson.faction.factionName,
+ role: gameperson.role,
+ group: gameperson.group ? true : false,
};
} else {
- throw new HttpException('No faction was found', HttpStatus.BAD_REQUEST);
+ return gameperson ? { role: gameperson.role } : { role: '' };
}
}
}
diff --git a/src/game/game.controller.ts b/src/game/game.controller.ts
index 8d7494ba4dfa4a77e22963600e45a7579fca5d5d..93068318edb8a99755c8cd44adaa795573888981 100644
--- a/src/game/game.controller.ts
+++ b/src/game/game.controller.ts
@@ -10,27 +10,43 @@ import {
UseInterceptors,
ClassSerializerInterceptor,
Delete,
+ UploadedFile,
+ Res,
} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { diskStorage } from 'multer';
+import { extname } from 'path';
import { GameService } from './game.service';
import { AuthGuard } from '../shared/auth.guard';
import { User } from '../user/user.decorator';
-import { GameDTO, FlagboxEventDTO, GameStateDTO } from './game.dto';
+import { GameDTO, FlagboxEventDTO, GameStateDTO, newGameDTO } from './game.dto';
import { ValidationPipe } from '../shared/validation.pipe';
import { Roles, GameStates } from '../shared/guard.decorator';
import { GameEntity } from './game.entity';
+/////////////////////////////////////////////////////////////////////////
+/// GameController ///
+/// ///
+/// Functions for creating, editing, deleting and listing games. ///
+/// Also there are functions to get objective point info and list ///
+/// of Factions in game ///
+/// ///
+/////////////////////////////////////////////////////////////////////////
+
@Controller('game')
export class GameController {
constructor(private gameservice: GameService) {}
+ //new game
@Post('new')
@UseGuards(new AuthGuard())
@UsePipes(new ValidationPipe())
- async newGame(@User('id') person, @Body() body: GameDTO) {
+ async newGame(@User('id') person, @Body() body: newGameDTO) {
return this.gameservice.createNewGame(person, body);
}
+ // edit game
@Put('edit/:id')
@Roles('admin')
@GameStates('CREATED')
@@ -40,6 +56,7 @@ export class GameController {
return this.gameservice.editGame(id, body);
}
+ // delete game
@Delete('delete/:id')
@Roles('admin')
@GameStates('CREATED')
@@ -47,6 +64,7 @@ export class GameController {
return this.gameservice.deleteGame(id);
}
+ // change game state
@Put('edit-state/:id')
@Roles('admin')
@UsePipes(new ValidationPipe())
@@ -54,9 +72,16 @@ export class GameController {
return this.gameservice.updateGameStatus(body);
}
+ // list all games
@Get('listgames')
- async listGames() {
- return this.gameservice.listGames();
+ async listGames(state) {
+ return this.gameservice.listGames(state);
+ }
+
+ // list games based on parameter
+ @Get('listgames/:state')
+ async listGamesState(@Param('state') state: string) {
+ return this.gameservice.listGames(state);
}
// ClassSerializerInterceptor removes excluded columns set in Entities
@@ -66,20 +91,57 @@ export class GameController {
return this.gameservice.returnGameInfo(id);
}
+ //get all factions
@Get('get-factions/:id')
@Roles('admin')
async returnGameFactions(@Param('id') id: GameEntity) {
return this.gameservice.listFactions(id);
}
+ // get flagbox events
+ @Get('flag-events/:id')
+ async returnFlagboxInfo(@Param('id') id: GameEntity) {
+ return this.gameservice.returnObjectivePointInfo(id);
+ }
+
+ // initial settings for flagbox
@Get('flag/:id')
async flagboxQuery(@Param('id') id: string) {
return this.gameservice.flagboxQuery(id);
}
+ // flagbox event
@Post('flag/:id')
@GameStates('STARTED')
async flagboxEvent(@Param('id') id: string, @Body() data: FlagboxEventDTO) {
return this.gameservice.flagboxEvent(id, data);
}
+
+ // image upload
+ @Post('upload')
+ @UseInterceptors(
+ FileInterceptor('image', {
+ storage: diskStorage({
+ destination: './images',
+ filename: (req, file, cb) => {
+ // Generating a 32 random chars long string
+ const randomName = Array(32)
+ .fill(null)
+ .map(() => Math.round(Math.random() * 16).toString(16))
+ .join('');
+ //Calling the callback passing the random name generated with the original extension name
+ cb(null, `${randomName}${extname(file.originalname)}`);
+ },
+ }),
+ }),
+ )
+ uploadImage(@UploadedFile() image) {
+ return image;
+ }
+
+ // get images
+ @Get('images/:img')
+ returnImage(@Param('img') image, @Res() res) {
+ return res.sendFile(image, { root: 'images' });
+ }
}
diff --git a/src/game/game.dto.ts b/src/game/game.dto.ts
index 266a8b1564e5b11fb42da755359c79d37f4b170b..a5bb525ddc6c34a17da91787a4bf5027405099f2 100644
--- a/src/game/game.dto.ts
+++ b/src/game/game.dto.ts
@@ -4,7 +4,6 @@ import {
Length,
IsDateString,
IsNumber,
- Validate,
Min,
Max,
ValidateNested,
@@ -15,7 +14,6 @@ import {
} from 'class-validator';
import { ObjectivePointEntity } from './game.entity';
-import { CenterJSON } from '../shared/custom-validation';
import { FactionDTO } from '../faction/faction.dto';
import { CenterDTO, NodeSettingsDTO } from './game.json.dto';
import { Type } from 'class-transformer';
@@ -62,21 +60,25 @@ export class newGameDTO {
@IsNotEmpty()
@Length(1, 255)
desc: string;
- @IsNotEmpty()
- @Validate(CenterJSON)
- center: JSON;
+ @ValidateNested()
+ @Type(() => CenterDTO)
+ center: CenterDTO;
@IsDateString()
@IsNotEmpty()
startdate: string;
@IsDateString()
@IsNotEmpty()
enddate: string;
+ @Length(0, 65)
+ image: string;
+ @Allow()
+ map?: JSON;
}
export class GameStateDTO {
@IsUUID('4')
id: string;
- @IsIn(['CREATED', 'STARTED', 'PAUSED', 'ENDED'])
+ @IsIn(['CREATED', 'STARTED', 'PAUSED', 'ENDED', 'ONGOING'])
state: string;
}
@@ -86,16 +88,18 @@ export class FlagboxDTO {
objectivePointId: string;
@IsString()
@IsNotEmpty()
- @Length(7)
+ @Length(7, 7)
objectivePointDescription: string;
@IsNumber()
objectivePointMultiplier: number;
+ @IsOptional()
+ data: JSON;
}
export class FlagboxEventDTO {
@IsString()
@IsNotEmpty()
- @Length(7)
+ @Length(7, 7)
node_id: string;
@IsNumber()
@Min(0)
@@ -109,6 +113,6 @@ export class FlagboxEventDTO {
@Min(0)
@Max(3)
capture: number; // which faction is capturing, same logic as in owner with numbers
- oP_HistoryTimestamp?: string;
+ oP_HistoryTimestamp?: number;
objective_point?: ObjectivePointEntity;
}
diff --git a/src/game/game.entity.ts b/src/game/game.entity.ts
index 7ae6e29955d02a2c1368b5f720200f009bd92ee1..56f3f3f6e2ffe341e6677e574bebf4b98b2b7be7 100644
--- a/src/game/game.entity.ts
+++ b/src/game/game.entity.ts
@@ -28,6 +28,7 @@ export class GameEntity {
@Column('text') state: string;
@Column('timestamp') startdate: Timestamp;
@Column('timestamp') enddate: Timestamp;
+ @Column('text') image: string;
@OneToMany(type => FactionEntity, factions => factions.game)
factions: FactionEntity[];
@@ -56,6 +57,7 @@ export class GameEntity {
export class Game_PersonEntity {
@PrimaryGeneratedColumn('uuid') gamepersonId: string;
@Column({ type: 'text', nullable: true }) role: string;
+ // If a Faction or Game where the GamePerson was in is deleted, the GamePerson is also deleted
@ManyToOne(type => FactionEntity, faction => faction.game_persons, {
onDelete: 'CASCADE',
})
@@ -68,6 +70,8 @@ export class Game_PersonEntity {
person: PersonEntity;
@OneToOne(type => GameGroupEntity, group => group.leader)
leaderGroup: GameGroupEntity;
+
+ // When a Group where GamePerson is is deleted, nothing happens to the GamePerson
@ManyToOne(type => GameGroupEntity, group => group.players, {
onDelete: 'NO ACTION',
})
@@ -80,22 +84,31 @@ export class ObjectivePointEntity {
@PrimaryGeneratedColumn('uuid') objectivePointId: string;
@Column({ type: 'text' }) objectivePointDescription: string;
@Column({ type: 'float' }) objectivePointMultiplier: number;
+ @Column({ type: 'json' }) data: JSON;
- @ManyToOne(type => MapDrawingEntity, coordinate => coordinate.data, {
- onDelete: 'CASCADE',
- })
- coordinate: MapDrawingEntity;
+ // If the Game where the ObjectivePoint was in is deleted, the ObjectivePoint is also deleted
@ManyToOne(type => GameEntity, game => game.objective_points, {
onDelete: 'CASCADE',
})
game: GameEntity;
+ @OneToMany(
+ () => ObjectivePoint_HistoryEntity,
+ history => history.objective_point,
+ {
+ onDelete: 'NO ACTION',
+ },
+ )
+ history: ObjectivePoint_HistoryEntity[];
}
@Entity('ObjectivePoint_History')
export class ObjectivePoint_HistoryEntity {
@PrimaryGeneratedColumn('uuid') oP_HistoryId: string;
- @Column({ type: 'timestamp' }) oP_HistoryTimestamp: Timestamp;
+ @Column({ type: 'float' }) oP_HistoryTimestamp: number;
@Column('float') action: number;
+
+ // If the owner Faction, capturer Faction or ObjectivePoint, that has, is trying to have or is the point where
+ // ObjectivePointHistory points to is deleted, the ObjectivePointHistory is also deleted
@ManyToOne(type => FactionEntity, factionEntity => factionEntity.factionId, {
onDelete: 'CASCADE',
})
diff --git a/src/game/game.module.ts b/src/game/game.module.ts
index 1c9e86faf59645bf537e76a8720bb6ab741fe6bd..b30424ced696027a22d255e8618c90ad40209f29 100644
--- a/src/game/game.module.ts
+++ b/src/game/game.module.ts
@@ -13,6 +13,14 @@ import { PersonEntity } from '../user/user.entity';
import { GameGroupEntity } from '../faction/faction.entity';
import { FactionEntity } from '../faction/faction.entity';
import { NotificationModule } from '../notifications/notifications.module';
+import { ScoreService } from '../score/score.service';
+import { ScoreEntity } from '../score/score.entity';
+import { MulterModule } from '@nestjs/platform-express';
+
+/////////////////////////////////////////////////////////////////////
+/// Game ///
+/// - contains everything to do with Game data ///
+/////////////////////////////////////////////////////////////////////
@Module({
imports: [
@@ -24,10 +32,14 @@ import { NotificationModule } from '../notifications/notifications.module';
GameGroupEntity,
ObjectivePointEntity,
ObjectivePoint_HistoryEntity,
+ ScoreEntity,
]),
NotificationModule,
+ MulterModule.register({
+ dest: './images',
+ }),
],
controllers: [GameController],
- providers: [GameService],
+ providers: [GameService, ScoreService],
})
export class GameModule {}
diff --git a/src/game/game.service.ts b/src/game/game.service.ts
index 3f6506b649f7dbe09936e283b4658f9765be8ec4..1567d30a1c5aa751de2ef9b0dff4d18af7af94d4 100644
--- a/src/game/game.service.ts
+++ b/src/game/game.service.ts
@@ -8,7 +8,7 @@ import {
ObjectivePointEntity,
ObjectivePoint_HistoryEntity,
} from './game.entity';
-import { GameDTO, FlagboxEventDTO, GameStateDTO } from './game.dto';
+import { GameDTO, FlagboxEventDTO, GameStateDTO, newGameDTO } from './game.dto';
import { PersonEntity } from '../user/user.entity';
import { FactionEntity } from '../faction/faction.entity';
import { NotificationGateway } from '../notifications/notifications.gateway';
@@ -30,9 +30,8 @@ export class GameService {
>,
private notificationGateway: NotificationGateway,
) {}
-
// create a new game
- async createNewGame(personId: PersonEntity, gameData: GameDTO) {
+ async createNewGame(personId: PersonEntity, gameData: newGameDTO) {
// checks if a game with the same name exists already
if (await this.gameRepository.findOne({ name: gameData.name })) {
throw new HttpException('Game already exists', HttpStatus.BAD_REQUEST);
@@ -81,6 +80,14 @@ export class GameService {
HttpStatus.BAD_REQUEST,
);
}
+ // check that there's location data for each added objective point
+ gameData.objective_points.forEach(obj => {
+ if (!obj['data'])
+ throw new HttpException(
+ 'Objective Point error. Add location for each Objective Point.',
+ HttpStatus.BAD_REQUEST,
+ );
+ });
// get factions that have been added previously
let factions = await this.factionRepository.find({ game: id });
@@ -119,8 +126,10 @@ export class GameService {
({ objectivePointId }) => objectivePointId,
);
flagboxes.map(async flagbox => {
- if (!flagboxIds.includes(flagbox.objectivePointDescription)) {
- await this.objectivePointRepository.delete(flagbox);
+ if (!flagboxIds.includes(flagbox.objectivePointId)) {
+ await this.objectivePointRepository.delete({
+ objectivePointId: flagbox.objectivePointId,
+ });
}
});
gameData.objective_points.map(async flagbox => {
@@ -129,13 +138,18 @@ export class GameService {
game: gameId,
});
await this.objectivePointRepository.save(newFlagbox);
+ // create base status for flagbox
+ this.flagboxEvent(gameId, {
+ node_id: flagbox.objectivePointDescription,
+ owner: 0,
+ action: 0,
+ capture: 0,
+ });
});
} else {
await this.objectivePointRepository.delete({ game: id });
}
- // TO DO: ADD FLAGBOX LOCATION TO MAPDRAWING ENTITY
-
return {
message: 'Game updated',
};
@@ -146,6 +160,7 @@ export class GameService {
if (updatedGame) {
updatedGame.state = game.state;
await this.gameRepository.save(updatedGame);
+
// notify players about game state change
this.notificationGateway.server.emit(game.id, {
type: 'gamestate-update',
@@ -162,7 +177,7 @@ export class GameService {
}
async deleteGame(id) {
- // TODO: Delete factions from Faction table associated with the deleted game
+ // Delete factions from Faction table associated with the deleted game
await this.gameRepository.delete({ id });
return {
message: 'Game deleted',
@@ -170,15 +185,35 @@ export class GameService {
}
// returns name and id of each game
- async listGames() {
- const games = await this.gameRepository.find();
- return games.map(game => {
- return game.gameObject();
- });
+ async listGames(state) {
+ if (state == null) {
+ const games = await this.gameRepository.find();
+ return games.map(game => {
+ return game.gameObject();
+ });
+ } else if (state == 'ONGOING') {
+ const games = await this.gameRepository.find({
+ where: [
+ { state: 'CREATED' },
+ { state: 'STARTED' },
+ { state: 'PAUSED' },
+ ],
+ });
+ return games.map(game => {
+ return game.gameObject();
+ });
+ } else {
+ const games = await this.gameRepository.find({
+ where: { state: state },
+ });
+ return games.map(game => {
+ return game.gameObject();
+ });
+ }
}
// returns information about a game identified by id
- async returnGameInfo(id: string) {
+ async returnGameInfo(id) {
const game = await this.gameRepository.findOne({
where: { id: id },
relations: ['factions', 'objective_points'],
@@ -190,6 +225,53 @@ export class GameService {
return game;
}
+ // returns information about game's flagboxes and their most recent event
+ async returnObjectivePointInfo(gameId) {
+ const info = await this.objectivePointRepository.find({
+ where: { game: gameId },
+ relations: ['history', 'history.owner', 'history.capture'],
+ });
+ let response = await Promise.all(
+ info.map(async obj => {
+ let history = obj.history.pop();
+ return await {
+ objectivePointId: obj.objectivePointId,
+ objectivePointDescription: obj.objectivePointDescription,
+ objectivePointMultiplier: obj.objectivePointMultiplier,
+ action: {
+ status: history.action,
+ message: {
+ 0: 'No capture ongoing',
+ 1: `Captured by ${
+ history.owner ? history.owner.factionName : 'neutral'
+ }`,
+ 2: `Being captured by ${
+ history.capture ? history.capture.factionName : 'neutral'
+ }`,
+ }[history.action],
+ },
+ owner: await this.infoHelper(history.owner),
+ capture: await this.infoHelper(history.capture),
+ data: obj.data,
+ };
+ }),
+ );
+ return response;
+ }
+
+ //returns flagbox colour and faction
+ private async infoHelper(obj) {
+ return (await obj)
+ ? {
+ factionName: obj.factionName,
+ colour: obj.colour,
+ }
+ : {
+ factionName: 'neutral',
+ colour: '#000000',
+ };
+ }
+
// returns flagbox settings
async flagboxQuery(gameId) {
const game = await this.gameRepository.findOne({ id: gameId });
@@ -204,7 +286,7 @@ export class GameService {
const objectiveRef = await this.objectivePointRepository.findOne({
where: { objectivePointDescription: data.node_id, game: gameId },
});
- data.oP_HistoryTimestamp = new Date(Date.now()).toLocaleString();
+ data.oP_HistoryTimestamp = Date.now();
const eventUpdate = await this.objectivePoint_HistoryRepository.create({
oP_HistoryTimestamp: data.oP_HistoryTimestamp,
action: data.action,
diff --git a/src/game/gameperson.decorator.ts b/src/game/gameperson.decorator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3e2a232880332fbd62b54f76bbb37bf91ef714e7
--- /dev/null
+++ b/src/game/gameperson.decorator.ts
@@ -0,0 +1,16 @@
+import { createParamDecorator } from '@nestjs/common';
+
+///////////////////////////////////////////////////////////////////////////
+/// gives service access to the gameperson object ///
+/// Game_PersonEntity { ///
+/// gamepersonId ///
+/// role ///
+/// faction ///
+/// } ///
+/// ///
+/// See more information from decorators in shared folder files. ///
+///////////////////////////////////////////////////////////////////////////
+
+export const GamePerson = createParamDecorator((data, req) => {
+ return data ? req.gameperson[data] : req.gameperson;
+});
diff --git a/src/main.ts b/src/main.ts
index 68871be82d89a37a410b93b252fb6f1e712ad143..20e08b20631984132638f542266bd34a38ef74ba 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,26 +1,21 @@
import { NestFactory } from '@nestjs/core';
-import * as rateLimit from 'express-rate-limit';
import { AppModule } from './app.module';
-/*
- Main.ts starts the server.
-*/
-
-// due to a bug with newest release of express-rate-limit, call for rateLimit is broken
-// (rateLimit as any) works as a workaround for now
-// see https://github.com/nfriedly/express-rate-limit/issues/138
-const limiter = (rateLimit as any)({
- windowMs: 60 * 1000, // one minute
- max: 100, // limit each IP to 100 requests per windowMs
-});
+///////////////////////////////////////////////////////////////////////////
+/// Main.ts starts the server. ///
+/// ///
+/// .env.PORT is not defined, port 5000 will be listened by default ///
+///////////////////////////////////////////////////////////////////////////
async function bootstrap() {
+ // port opened
+ const port = 5000;
+
const app = await NestFactory.create(AppModule);
// Cors is needed for application/json POST
app.enableCors();
- // apply limiter to all routes
- app.use(limiter);
- await app.listen(5000);
+ // Server will listen on port
+ await app.listen(process.env.PORT || port);
}
bootstrap();
diff --git a/src/notifications/notification.entity.ts b/src/notifications/notification.entity.ts
index f9d5dca9290c30da406a63adf56ee06fe716a7b5..5e1f841cf031767574c75d54af65ca209fc7e86b 100644
--- a/src/notifications/notification.entity.ts
+++ b/src/notifications/notification.entity.ts
@@ -16,6 +16,7 @@ export class NotificationEntity {
@Column({ type: 'text' }) message: string;
@CreateDateColumn() issued: Date;
+ // Notifications are deleted if the game is deleted
@ManyToOne(type => GameEntity, game => game.id, {
onDelete: 'CASCADE',
})
diff --git a/src/notifications/notifications.controller.ts b/src/notifications/notifications.controller.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83101be3d6cb57b58f5147ddbf0347a3291bb5db
--- /dev/null
+++ b/src/notifications/notifications.controller.ts
@@ -0,0 +1,16 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { NotificationsService } from './notifications.service';
+import { Roles } from 'src/shared/guard.decorator';
+
+@Controller('notifications')
+export class NotificationsController {
+ constructor(private notificationService: NotificationsService) {}
+
+ // get all sent notifications for game
+ // :id is the id of the game
+ @Get(':id')
+ @Roles('admin', 'factionleader', 'soldier', 'groupleader')
+ async(@Param('id') gameId) {
+ return this.notificationService.getNotifications(gameId);
+ }
+}
diff --git a/src/notifications/notifications.gateway.ts b/src/notifications/notifications.gateway.ts
index 5e952d6c78c6f35977f362a7459c0ebf65d1ab5e..79fcc0e5f287858f1cf62862dde722e372ba8ef9 100644
--- a/src/notifications/notifications.gateway.ts
+++ b/src/notifications/notifications.gateway.ts
@@ -16,6 +16,10 @@ import { GameEntity } from '../game/game.entity';
import { NotificationdDTO } from './notification.dto';
import { ValidationPipe } from '../shared/validation.pipe';
+///////////////////////////////////////////////////////////////////////////////////
+/// NotificationGateway contains websocket server and listener for game-info ///
+///////////////////////////////////////////////////////////////////////////////////
+
@WebSocketGateway()
export class NotificationGateway
implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
@@ -50,12 +54,25 @@ export class NotificationGateway
async handleMessage(client: Socket, data: NotificationdDTO) {
// check if the game exists and is either started or paused
const game = await this.gameRepository.findOne({ id: data.game });
- if (game && ['STARTED', 'PAUSED'].includes(game.state)) {
+ if (!game) {
+ // inform user about error
+ this.server.to(client.id).emit(data.game, {
+ type: 'error',
+ message: 'Game was not found',
+ });
+ }
+ if (['STARTED', 'PAUSED'].includes(game.state)) {
// send the message to all clients listening to gameId branch
this.server.emit(data.game, data);
// create entry for notification in db
const message = await this.notificationRepository.create(data);
await this.notificationRepository.insert(message);
+ } else {
+ // inform user about error
+ this.server.to(client.id).emit(data.game, {
+ type: 'error',
+ message: 'Notifications can be sent only in STARTED and PAUSED state',
+ });
}
}
}
diff --git a/src/notifications/notifications.module.ts b/src/notifications/notifications.module.ts
index 41e2fcaa36d1928dff9a60bd2c6853e240baf16f..5ca243fcb3c39c6d49298beff12de51634575e19 100644
--- a/src/notifications/notifications.module.ts
+++ b/src/notifications/notifications.module.ts
@@ -4,10 +4,18 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { NotificationGateway } from './notifications.gateway';
import { NotificationEntity } from './notification.entity';
import { GameEntity } from '../game/game.entity';
+import { NotificationsController } from './notifications.controller';
+import { NotificationsService } from './notifications.service';
+
+/////////////////////////////////////////////////////////////////////
+/// Notification ///
+/// - contains everything to do with Notification data. ///
+/////////////////////////////////////////////////////////////////////
@Module({
imports: [TypeOrmModule.forFeature([NotificationEntity, GameEntity])],
- providers: [NotificationGateway],
+ providers: [NotificationGateway, NotificationsService],
exports: [NotificationGateway],
+ controllers: [NotificationsController],
})
export class NotificationModule {}
diff --git a/src/notifications/notifications.service.ts b/src/notifications/notifications.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0bbe016ecba9bde516b99222bbe388b3269bba6c
--- /dev/null
+++ b/src/notifications/notifications.service.ts
@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { NotificationEntity } from './notification.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class NotificationsService {
+ constructor(
+ @InjectRepository(NotificationEntity)
+ private notificationRepository: Repository<NotificationEntity>,
+ ) {}
+
+ // finds all notifications for specified game
+ async getNotifications(game: string) {
+ return this.notificationRepository.find({ game });
+ }
+}
diff --git a/src/replay/replay.controller.ts b/src/replay/replay.controller.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e39e99d8ba1e5be763e21fc1e00b6496e6e95648
--- /dev/null
+++ b/src/replay/replay.controller.ts
@@ -0,0 +1,33 @@
+import {
+ Controller,
+ Get,
+ Param,
+ Post,
+ UseInterceptors,
+ ClassSerializerInterceptor,
+} from '@nestjs/common';
+import { ReplayService } from './replay.service';
+import { Roles } from 'src/shared/guard.decorator';
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// POST mockdata is mainly used for development, it can be removed from the code when needed, remember to remove service & test relations. ///
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@Controller('replay')
+export class ReplayController {
+ constructor(private replayservice: ReplayService) {}
+
+ // gets replay data for specified Game
+ @Get(':id')
+ @UseInterceptors(ClassSerializerInterceptor)
+ async replayInfo(@Param('id') gameId) {
+ return this.replayservice.replayData(gameId);
+ }
+
+ // gets mockdata for specified Game
+ @Post('mockdata/:id')
+ @Roles('admin')
+ async mockData(@Param('id') gameId) {
+ return this.replayservice.mockdata(gameId);
+ }
+}
diff --git a/src/replay/replay.module.ts b/src/replay/replay.module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..961e599e4cb9aca8a27dac015b83edb386e41e64
--- /dev/null
+++ b/src/replay/replay.module.ts
@@ -0,0 +1,59 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ReplayController } from './replay.controller';
+import { ReplayService } from './replay.service';
+import {
+ GameEntity,
+ Game_PersonEntity,
+ ObjectivePointEntity,
+ ObjectivePoint_HistoryEntity,
+} from '../game/game.entity';
+import { FactionEntity, GameGroupEntity } from '../faction/faction.entity';
+import { UserService } from '../user/user.service';
+import { FactionService } from '../faction/faction.service';
+import { TrackingService } from '../tracking/tracking.service';
+import { TrackingEntity } from '../tracking/tracking.entity';
+import { PersonEntity } from '../user/user.entity';
+import {
+ MapDrawingEntity,
+ MapDrawingHistoryEntity,
+} from '../draw/coordinate.entity';
+import { ScoreService } from '../score/score.service';
+import { ScoreEntity } from '../score/score.entity';
+import { NotificationModule } from '../notifications/notifications.module';
+import { GameService } from '../game/game.service';
+
+/////////////////////////////////////////////////////////////////////
+/// Replay ///
+/// - contains everything to do with Replay data. ///
+/////////////////////////////////////////////////////////////////////
+
+@Module({
+ imports: [
+ TypeOrmModule.forFeature([
+ PersonEntity,
+ GameEntity,
+ FactionEntity,
+ TrackingEntity,
+ GameGroupEntity,
+ Game_PersonEntity,
+ MapDrawingEntity,
+ MapDrawingHistoryEntity,
+ ScoreEntity,
+ ObjectivePointEntity,
+ ObjectivePoint_HistoryEntity,
+ ]),
+ NotificationModule,
+ ],
+ controllers: [ReplayController],
+ providers: [
+ ReplayService,
+ UserService,
+ FactionService,
+ TrackingService,
+ ScoreService,
+ GameService,
+ ],
+})
+export class ReplayModule {}
diff --git a/src/replay/replay.service.ts b/src/replay/replay.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be423495a09073676a7c7b81916876b23f5ecf38
--- /dev/null
+++ b/src/replay/replay.service.ts
@@ -0,0 +1,323 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as jwt from 'jsonwebtoken';
+
+import { FactionEntity } from '../faction/faction.entity';
+import {
+ GameEntity,
+ ObjectivePointEntity,
+ ObjectivePoint_HistoryEntity,
+} from '../game/game.entity';
+import { TrackingService } from '../tracking/tracking.service';
+import { UserService } from '../user/user.service';
+import { FactionService } from '../faction/faction.service';
+import { TrackingEntity } from '../tracking/tracking.entity';
+import {
+ MapDrawingEntity,
+ MapDrawingHistoryEntity,
+} from '../draw/coordinate.entity';
+import { ScoreService } from '../score/score.service';
+import { ScoreEntity } from '../score/score.entity';
+import { GameService } from '../game/game.service';
+
+@Injectable()
+export class ReplayService {
+ constructor(
+ @InjectRepository(FactionEntity)
+ private factionRepository: Repository<FactionEntity>,
+ @InjectRepository(GameEntity)
+ private gameRepository: Repository<GameEntity>,
+ @InjectRepository(TrackingEntity)
+ private trackingRepository: Repository<TrackingEntity>,
+ @InjectRepository(MapDrawingEntity)
+ private mapdrawingRepository: Repository<MapDrawingEntity>,
+ @InjectRepository(MapDrawingHistoryEntity)
+ private mapHistoryRepository: Repository<MapDrawingHistoryEntity>,
+ @InjectRepository(ScoreEntity)
+ private scoreRepository: Repository<ScoreEntity>,
+ @InjectRepository(ObjectivePointEntity)
+ private objectivepointRepository: Repository<ObjectivePointEntity>,
+ private trackingService: TrackingService,
+ private userService: UserService,
+ private factionService: FactionService,
+ private scoreService: ScoreService,
+ private gameService: GameService,
+ ) {}
+
+ async replayData(gameId) {
+ // this block returns game's initial location
+ let gameObj = await this.gameRepository.findOne({
+ where: { id: gameId },
+ select: ['center'],
+ });
+ let gamelocation = [gameObj.center.lat, gameObj.center.lng];
+ // this block returns all player data from the game
+ let playerdata = await this.trackingRepository.find({
+ where: { game: gameId },
+ relations: ['faction', 'gamepersonId', 'gamepersonId.person'],
+ });
+ // parse data
+ const currentdata = await Promise.all(
+ playerdata.map(async player => {
+ player.data.map(async data => {
+ data['info'] = [
+ { key: 'icon', value: player.icon },
+ { key: 'colour', value: player.faction.colour },
+ { key: 'name', value: player.gamepersonId.person.name },
+ { key: 'role', value: player.gamepersonId.role },
+ ];
+ });
+ return player['data'];
+ }),
+ );
+
+ // this block returns all faction data from the game
+
+ let factions = await this.factionRepository.find({ game: gameId });
+ let currentFactions = factions.map(faction => {
+ return {
+ name: faction.factionName,
+ colour: faction.colour,
+ // all factions will be rendered on the map on default
+ active: true,
+ };
+ });
+
+ // this block returns all score data from the game
+ let currentScore = [];
+ await Promise.all(
+ factions.map(async faction => {
+ let scores = await this.scoreRepository.find({
+ where: { faction: faction },
+ relations: ['faction'],
+ });
+ currentScore.push(
+ scores.map(score => {
+ return {
+ score: score.score,
+ timestamp: score.scoreTimeStamp,
+ faction: score.faction['factionName'],
+ };
+ }),
+ );
+ }),
+ );
+
+ // this block returns all map drawings from the game
+
+ let refs = await this.mapdrawingRepository.find({
+ where: { gameId: gameId },
+ select: ['mapDrawingId'],
+ });
+
+ let drawData = await Promise.all(
+ refs.map(async ref => {
+ return await this.mapHistoryRepository.find({
+ where: { mapdrawing: ref.mapDrawingId },
+ });
+ }),
+ );
+
+ // this function returns all flagbox-events from the game
+
+ let objectivepoints = await this.returnObjectivePointInfo(gameId);
+
+ return {
+ location: gamelocation,
+ players: currentdata,
+ factions: currentFactions,
+ scores: currentScore,
+ drawings: drawData,
+ objectivepoints: objectivepoints,
+ };
+ }
+
+ // returns information about game's flagboxes and all of their events
+ async returnObjectivePointInfo(gameId) {
+ const info = await this.objectivepointRepository.find({
+ where: { game: gameId },
+ relations: ['history', 'history.owner', 'history.capture'],
+ });
+ let response = await Promise.all(
+ info.map(async obj => {
+ return await {
+ objectivePointId: obj.objectivePointId,
+ objectivePointDescription: obj.objectivePointDescription,
+ objectivePointMultiplier: obj.objectivePointMultiplier,
+ data: obj.data,
+ history: await this.parseHistory(obj.history),
+ };
+ }),
+ );
+ return response;
+ }
+
+ // loops all events in history array and returns an array of objects formatted for replay
+ private async parseHistory(history: ObjectivePoint_HistoryEntity[]) {
+ return await Promise.all(
+ history.map(async event => {
+ return {
+ timestamp: event.oP_HistoryTimestamp,
+ action: {
+ status: event.action,
+ message: {
+ 0: 'No capture ongoing',
+ 1: `Captured by ${
+ event.owner ? event.owner.factionName : 'neutral'
+ }`,
+ 2: `Being captured by ${
+ event.capture ? event.capture.factionName : 'neutral'
+ }`,
+ }[event.action],
+ },
+ owner: await this.infoHelper(event.owner),
+ capture: await this.infoHelper(event.capture),
+ };
+ }),
+ );
+ }
+
+ // small helper function that formats data for replay
+ private async infoHelper(obj) {
+ return (await obj)
+ ? {
+ factionName: obj.factionName,
+ colour: obj.colour,
+ }
+ : {
+ factionName: 'neutral',
+ colour: '#000000',
+ };
+ }
+ // generate mockdata for a 3 day game
+ // create x amount of players
+ // assign them to two separate factions
+ // assign them to three separate groups
+ // insert x amount of locations for each players around some lat lng area
+ // insert x amont of flagbox events
+ // insert x amount of score ticks for score mockdata
+ // use the game's initial geojson to draw game area
+
+ async mockdata(gameId) {
+ // initial settings for mockdata
+ // set the x amount of users to be created
+ const USER_AMOUNT = 100;
+ // set the x amount of locations to be created
+ const USER_LOCATIONS = 10;
+ // set the LAT and LNG for initial location
+ const LAT = 62.24147;
+ const LNG = 25.72088;
+ // set the x amount of flagbox events
+ // not used at the moment
+ const FLAGBOX_EVENTS = 8;
+ // set the score tick amount
+ // not used at the moment
+ const SCORE_TICKS = 10;
+ // setup the arrays for users, gamepersons and groups
+ const users = [];
+ const gamepersons = [];
+ const groups = [];
+ // characters for generating random usernames and the length of the username
+ const chars =
+ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+ const N = 15;
+ // used to equally divide the players to factions
+ let f = 0;
+
+ // get game info and factions associated with it
+ const game = await this.gameRepository.findOne({
+ where: { id: gameId },
+ relations: ['factions'],
+ });
+ // get groups for all factions
+ await game.factions.forEach(async faction => {
+ groups.push(await this.factionService.showGroups(faction.factionId));
+ });
+ // get all objective point refs
+ const objectivepoints = await this.objectivepointRepository.find({
+ game: gameId,
+ });
+ // create x amount of users for the mock game with random username
+ for (let i = 0; i < USER_AMOUNT; i++) {
+ let res = await this.userService.register({
+ name: Array(N)
+ .join()
+ .split(',')
+ .map(function() {
+ return chars.charAt(Math.floor(Math.random() * chars.length));
+ })
+ .join(''),
+ password: 'asd',
+ });
+ // get user information by verifying the token returned by register
+ let user = await jwt.verify(res.token, process.env.SECRET);
+ // push the created user to users array
+ users.push(user);
+
+ // reset index if it's out of range
+ if (f === game.factions.length) f = 0;
+ // join faction with the created user
+ let gameperson = await this.factionService.joinFaction(user['id'], {
+ factionId: game.factions[f].factionId,
+ factionPassword: game.factions[f].factionPassword,
+ game: gameId,
+ });
+ // join a group randomly
+ await this.factionService.joinGroup(gameperson, {
+ groupId: groups[f][Math.floor(Math.random() * 3)],
+ });
+ // push the gameperson ref to gamepersons array
+ gamepersons.push(gameperson);
+ f++;
+ }
+ // push x amount of user locations
+ for (let i = 1; i < USER_LOCATIONS + 1; i++) {
+ let date: number = Date.now();
+ let x = 1;
+ // score ticks with players to sync them
+ await this.scoreService.scoreTick(gameId);
+ // flagbox events with players to sync them
+ // use helper function to generate a random event
+ let event = await this.createEvent(objectivepoints);
+ await this.gameService.flagboxEvent(gameId, event);
+ // add location entry for each gameperson
+ await Promise.all(
+ gamepersons.map(async gameperson => {
+ // format player locations with x-modifier that same factions are closer to each other
+ if (x > game.factions.length) x = 1;
+ let dataObject = {
+ lat: LAT + ((i + Math.random()) * 5) / 2000,
+ lng: LNG + x / 100 + (Math.random() * 5) / 2000,
+ time: date,
+ };
+ x++;
+ // push the tracking data
+ await this.trackingService.trackLocation(
+ gameperson,
+ gameId,
+ dataObject,
+ );
+ }),
+ );
+ }
+
+ return {
+ message: 'all done',
+ };
+ }
+
+ // creates randomized events for randomly chosen flagbox
+ // may result in impossible scenarios where owner is capturing their own flagbox
+ // use only for testing flagbox replay functionalities
+ private async createEvent(objectivepoints: ObjectivePointEntity[]) {
+ let point =
+ objectivepoints[Math.floor(Math.random() * objectivepoints.length)];
+ return await {
+ node_id: point.objectivePointDescription,
+ owner: Math.round(Math.random()) + 1,
+ action: Math.round(Math.random()) ? 2 : 0,
+ capture: Math.round(Math.random()) + 1,
+ };
+ }
+}
diff --git a/src/score/score.controller.ts b/src/score/score.controller.ts
index 73fda22e699f5702b1616360bd7e95f0ac8aeb10..344c33c02a84f1e49b202090dffedb0d42d23ce8 100644
--- a/src/score/score.controller.ts
+++ b/src/score/score.controller.ts
@@ -1,4 +1,13 @@
-import { Controller, Post, UsePipes, Body, Param, Get } from '@nestjs/common';
+import {
+ Controller,
+ Post,
+ UsePipes,
+ Body,
+ Param,
+ Get,
+ UseInterceptors,
+ ClassSerializerInterceptor,
+} from '@nestjs/common';
import { ValidationPipe } from '../shared/validation.pipe';
import { ScoreService } from './score.service';
@@ -20,16 +29,9 @@ export class ScoreController {
return this.scoreService.addScore(data, gameId);
}
- // temporary scoreTick path, :id is gameId
- @Get('tick-score/:id')
- @GameStates('STARTED')
- async scoreTick(@Param('id') gameId: GameEntity) {
- return this.scoreService.scoreTick(gameId);
- }
-
- // shows scores, :id is gameId
+ // shows scores, :id is gameId
@Get('get-score/:id')
- @GameStates('STARTED')
+ @UseInterceptors(ClassSerializerInterceptor)
async getScores(@Param('id') gameId: GameEntity) {
return this.scoreService.getScores(gameId);
}
diff --git a/src/score/score.dto.ts b/src/score/score.dto.ts
index 99955f56eff34a41ce46111d7fd0cb9cd597386f..2feecbfd8aecd189d9fb1f8239abf2793fe6051b 100644
--- a/src/score/score.dto.ts
+++ b/src/score/score.dto.ts
@@ -3,7 +3,7 @@ import { IsNumber, Min, Max, IsUUID } from 'class-validator';
export class ScoreDTO {
@IsNumber()
@Min(1)
- @Max(99)
+ @Max(999)
score: number;
@IsUUID('4')
faction: string;
diff --git a/src/score/score.entity.ts b/src/score/score.entity.ts
index 6ca9ab77b968060a6dc88c860425119914cec030..01fb60bf11ad23461f9bba6492b6ebea68c61c45 100644
--- a/src/score/score.entity.ts
+++ b/src/score/score.entity.ts
@@ -1,19 +1,13 @@
-import {
- Entity,
- PrimaryGeneratedColumn,
- Column,
- ManyToOne,
- Timestamp,
- CreateDateColumn,
-} from 'typeorm';
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { FactionEntity } from '../faction/faction.entity';
@Entity('Score')
export class ScoreEntity {
@PrimaryGeneratedColumn('uuid') scoreId: string;
@Column({ type: 'float' }) score: number;
- @CreateDateColumn({ type: 'timestamp' }) scoreTimeStamp: Timestamp;
+ @Column({ type: 'float' }) scoreTimeStamp: number;
+ // when Faction is deleted, it's Score is also deleted
@ManyToOne(type => FactionEntity, factionName => factionName.factionId, {
onDelete: 'CASCADE',
})
diff --git a/src/score/score.module.ts b/src/score/score.module.ts
index c04486fc676fca0d7c6a38c74374e03e23a1008c..9ce2f41c5c8ab0cbdbf4c11d1709f305323ba870 100644
--- a/src/score/score.module.ts
+++ b/src/score/score.module.ts
@@ -11,6 +11,11 @@ import {
import { ScoreEntity } from './score.entity';
import { NotificationModule } from '../notifications/notifications.module';
+/////////////////////////////////////////////////////////////////////
+/// Score ///
+/// - contains everything to do with Score data. ///
+/////////////////////////////////////////////////////////////////////
+
@Module({
imports: [
TypeOrmModule.forFeature([
diff --git a/src/score/score.service.ts b/src/score/score.service.ts
index dba8e6e79206322a4dffae937b5af6b2bdd89041..ab6d522a805a00dc4456c5a64f550d30ff34fffd 100644
--- a/src/score/score.service.ts
+++ b/src/score/score.service.ts
@@ -26,30 +26,15 @@ export class ScoreService {
private notificationGateway: NotificationGateway,
) {}
- async addScore(scoreData: ScoreDTO, gameId: GameEntity) {
- // check if faction exists
- const faction = await this.factionRepository.findOne({
- factionId: scoreData.faction,
- });
- if (!faction) {
- throw new HttpException('Faction was not found', HttpStatus.BAD_REQUEST);
- }
- // get the previous score and add it, if it exists
- let lastScore = await this.scoreRepository.findOne({
- where: { faction: scoreData.faction },
- order: { scoreTimeStamp: 'DESC' },
- });
- if (lastScore) {
- scoreData.score += lastScore.score;
- }
- // add the score for Faction
- const newScore = await this.scoreRepository.create(scoreData);
- await this.scoreRepository.insert(newScore);
+ async addScore(scoreData: ScoreDTO, gameId) {
+ await this.pushScore(scoreData);
+ this.notificationGateway.server.emit(gameId, { type: 'score-update' });
return {
message: 'Score updated!',
};
}
+ // function to run on timer tick
async scoreTick(gameId) {
// get game's flagboxes
const flagboxes = await this.flagRepository.find({ game: gameId });
@@ -69,7 +54,8 @@ export class ScoreService {
i => i.faction === current.owner.factionId,
);
index !== -1
- ? await (scoreData[index]['score'] += box.objectivePointMultiplier)
+ ? await (scoreData[index]['score'] +=
+ box.objectivePointMultiplier * current.owner.multiplier)
: await scoreData.push({
score: box.objectivePointMultiplier,
faction: current.owner.factionId,
@@ -78,7 +64,7 @@ export class ScoreService {
}),
);
scoreData.map(async data => {
- await this.addScore(data, gameId);
+ await this.pushScore(data);
});
this.notificationGateway.server.emit(gameId, { type: 'score-update' });
return {
@@ -86,34 +72,48 @@ export class ScoreService {
};
}
+ private async pushScore(scoreData: ScoreDTO) {
+ // check if faction exists
+ const faction = await this.factionRepository.findOne({
+ factionId: scoreData.faction,
+ });
+ if (!faction) {
+ throw new HttpException('Faction was not found', HttpStatus.BAD_REQUEST);
+ }
+ // get the previous score and add it, if it exists
+ let lastScore = await this.scoreRepository.findOne({
+ where: { faction: scoreData.faction },
+ order: { scoreTimeStamp: 'DESC' },
+ });
+ if (lastScore) {
+ scoreData.score += lastScore.score * faction.multiplier;
+ }
+ // add the score for Faction
+ const newScore = await this.scoreRepository.create(scoreData);
+ newScore.scoreTimeStamp = Date.now();
+ await this.scoreRepository.insert(newScore);
+ }
+
async getScores(gameId: GameEntity) {
// find games factions
const factions = await this.factionRepository.find({
- where: {game: gameId,},
+ where: { game: gameId },
relations: ['game'],
});
let scores = [];
await Promise.all(
factions.map(async factionNow => {
let score = await this.scoreRepository.findOne({
- where: {faction: factionNow},
+ where: { faction: factionNow },
relations: ['faction'],
- order: {scoreTimeStamp: 'DESC'},
+ order: { scoreTimeStamp: 'DESC' },
});
//if score was found, put info to scores array
if (score.faction) {
- let index = await scores.findIndex(
- i => i.faction === score.faction,
- );
scores.push(score);
}
- }))
- return scores;
+ }),
+ );
+ return scores;
}
-} //
-
-// Hae kaikki Objective pointit
-// aja map funktio pelin objective pointteihin
-// jokaisella objective point ID:llä hae historystä
-// relaatio, missä uusin timestamp
-// katso uusimmista history entrystä omistaja
+}
diff --git a/src/shared/auth.guard.ts b/src/shared/auth.guard.ts
index ff2bdf406d5badffc467cdf22d0f61935aae0af8..acde301a9dca4202d4971a3b34e6d251dc07a7c1 100644
--- a/src/shared/auth.guard.ts
+++ b/src/shared/auth.guard.ts
@@ -7,6 +7,14 @@ import {
} from '@nestjs/common';
import * as jwt from 'jsonwebtoken';
+/////////////////////////////////////////////////////////
+/// https://docs.nestjs.com/guards ///
+/// AuthGuard verifies the user's token ///
+/// It adds user information to request.user ///
+/// which can be used by UserDecorator in services ///
+/// return 403 if token validation fails ///
+/////////////////////////////////////////////////////////
+
@Injectable()
export class AuthGuard implements CanActivate {
// check for logged in user
diff --git a/src/shared/custom-validation.ts b/src/shared/custom-validation.ts
deleted file mode 100644
index 13b96372e0b76a2897364baa15562edf383a2d81..0000000000000000000000000000000000000000
--- a/src/shared/custom-validation.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import {
- ValidatorConstraint,
- ValidatorConstraintInterface,
- ValidationArguments,
- Validator,
-} from 'class-validator';
-
-// check if input is null or valid uuid
-@ValidatorConstraint({ name: 'uuid', async: true })
-export class Uuid implements ValidatorConstraintInterface {
- validate(uuid: string, args: ValidationArguments) {
- const validator = new Validator();
- return validator.isUUID(uuid, '4') || uuid == null; // for async validations you must return a Promise<boolean> here
- }
-
- defaultMessage(args: ValidationArguments) {
- return 'Not valid uuid';
- }
-}
-
-// checks if role is valid
-@ValidatorConstraint({ name: 'roleValidation', async: true })
-export class RoleValidation implements ValidatorConstraintInterface {
- validate(role: string, args: ValidationArguments) {
- const validRoles = ['admin', 'soldier', 'factionleader'];
- return validRoles.includes(role);
- }
-
- defaultMessage(args: ValidationArguments) {
- return 'Not valid uuid';
- }
-}
-
-// checks for valid JSON for center
-@ValidatorConstraint({ name: 'centerJSON', async: true })
-export class CenterJSON implements ValidatorConstraintInterface {
- validate(center: JSON, args: ValidationArguments) {
- const validator = new Validator();
- return (
- validator.isNumber(center['lat']) &&
- validator.isNumber(center['lng']) &&
- validator.min(center['lat'], -90) &&
- validator.max(center['lat'], 90) &&
- validator.min(center['lng'], -180) &&
- validator.max(center['lng'], 180)
- );
- }
-
- defaultMessage(args: ValidationArguments) {
- return 'Error with center JSON';
- }
-}
diff --git a/src/shared/guard.decorator.ts b/src/shared/guard.decorator.ts
index b299d6de913f54dd496c344f6dcdafd2942b2c9c..a313b3a6e52321b70b2f9768b5131252cb7816f7 100644
--- a/src/shared/guard.decorator.ts
+++ b/src/shared/guard.decorator.ts
@@ -1,5 +1,12 @@
import { SetMetadata } from '@nestjs/common';
+/////////////////////////////////////////////////////////
+/// pass information from controllers to guards ///
+/// for example @Roles("admin") passes it to ///
+/// roles.guard, which compares user's role ///
+/// to the values return by SetMetadata ///
+/////////////////////////////////////////////////////////
+
export const Roles = (...roles: string[]) => SetMetadata('roles', roles);
export const GameStates = (...states: string[]) =>
diff --git a/src/shared/http-error.filter.ts b/src/shared/http-error.filter.ts
index 8a65068c4275c4a8d576da54b0340c17b6ac8cc4..bf7316fa20d8c5e3107a10b0972a1d1d9e18e940 100644
--- a/src/shared/http-error.filter.ts
+++ b/src/shared/http-error.filter.ts
@@ -7,6 +7,12 @@ import {
HttpStatus,
} from '@nestjs/common';
+/////////////////////////////////////////////////////////
+/// Global tryCatch for catching errors in services ///
+/// Returns error message for end-users ///
+/// Also logs the error in console ///
+/////////////////////////////////////////////////////////
+
@Catch()
export class HttpErrorFilter implements ExceptionFilter {
catch(exception: HttpException, host: ArgumentsHost) {
diff --git a/src/shared/logging.interceptor.ts b/src/shared/logging.interceptor.ts
index 55083faabd0a781ace687fc2cb9c2977f0befaa9..c29717474c87516cc3e1492bc24a5f13f848c89a 100644
--- a/src/shared/logging.interceptor.ts
+++ b/src/shared/logging.interceptor.ts
@@ -1,7 +1,13 @@
-import { Injectable, NestInterceptor, ExecutionContext, CallHandler, Logger } from '@nestjs/common';
+import {
+ Injectable,
+ NestInterceptor,
+ ExecutionContext,
+ CallHandler,
+ Logger,
+} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
-
+/*
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
intercept(
@@ -19,4 +25,4 @@ export class LoggingInterceptor implements NestInterceptor {
))
)
}
-}
\ No newline at end of file
+}*/
diff --git a/src/shared/roles.controller.ts b/src/shared/roles.controller.ts
deleted file mode 100644
index 0d91e061c7fea732af225819e87f8529ff326eab..0000000000000000000000000000000000000000
--- a/src/shared/roles.controller.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-const AccessControl = require('accesscontrol');
-
-const grants = {
- admin: {
- mapmarker: {
- 'create:any': [],
- 'delete:any': [],
- 'read:any': [],
- 'update:any': [],
- },
- powerup: {
- 'create:any': [],
- 'delete:any': [],
- 'read:any': [],
- 'update:any': [],
- },
- faction: {
- 'create:any': [],
- 'delete:any': [],
- 'read:any': [],
- 'update:any': [],
- },
- players: {
- 'create:any': [],
- 'delete:any': [],
- 'read:any': [],
- 'update:any': [],
- },
- },
- faction_leader: {
- mapmarker: {
- 'create:own': [],
- 'delete:own': [],
- 'read:own': [],
- },
- powerup: {
- 'read:own': [],
- },
- faction: {
- 'read:own': [],
- 'update:own': [],
- },
- players: {
- 'read:own': [],
- 'update:own': [],
- },
- },
- //player & spectator
-};
-
-const ac = new AccessControl(grants);
-
-/*const express = require ('express');
-const router express.Router;
-
-const ac = new AccessControl();
-ac.grant('faction_leader') // define new or modify existing role. also takes an array.
- .createOwn('mapmarker') // equivalent to .createOwn('video', ['*'])
- .deleteOwn('mapmarker')
- .readOwn('mapmarker')
- .grant('admin') // switch to another role without breaking the chain
- .extend('user') // inherit role capabilities. also takes an array
- .updateAny('mapmarker', ['title']) // explicitly defined attributes
- .deleteAny('mapmarker')
- .readAny('mapmarker');
-
-//const
-let permission = ac.can('user').createOwn('mapmarker');
-console.log(permission.granted); // —> true
-console.log(permission.attributes); // —> ['*'] (all attributes)
-
-permission = ac.can('admin').updateAny('mapmarker');
-console.log(permission.granted); // —> true
-console.log(permission.attributes); // —> ['title']
-
-router.get('/videos/:title', function (req, res, next) {
- const permission = ac.can(req.user.role).readAny('video');
- if (permission.granted) {
- Video.find(req.params.title, function (err, data) {
- if (err || !data) return res.status(404).end();
- // filter data by permission attributes and send.
- res.json(permission.filter(data));
- });
- } else {
- // resource is forbidden for this user/role
- res.status(403).end();
- }
-});*/
diff --git a/src/shared/roles.guard.ts b/src/shared/roles.guard.ts
index 73693f9e1551da1b1b34056a665eb59c1211b3ef..5e97482e408df52075c4e97553707e32ca70a447 100644
--- a/src/shared/roles.guard.ts
+++ b/src/shared/roles.guard.ts
@@ -9,9 +9,19 @@ import { Reflector } from '@nestjs/core';
import * as jwt from 'jsonwebtoken';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
+import { Validator } from 'class-validator';
import { Game_PersonEntity } from '../game/game.entity';
+/////////////////////////////////////////////////////////
+/// https://docs.nestjs.com/guards ///
+/// RolesGuard verifies the user's token and role ///
+/// It adds user information to request.user ///
+/// which can be used by GamePerson ///
+/// decorator in services ///
+/// return 403 if token/role validation fails ///
+/////////////////////////////////////////////////////////
+
@Injectable()
export class RolesGuard implements CanActivate {
constructor(
@@ -32,11 +42,20 @@ export class RolesGuard implements CanActivate {
return false;
}
const gameId = request.params.id;
+ // create a valifator
+ const validator = new Validator();
+ // verify UUID
+ if (!validator.isUUID(gameId)) {
+ throw new HttpException('Game not found', HttpStatus.BAD_REQUEST);
+ }
request.user = await this.getUserObject(request.headers.authorization);
const role = await this.game_PersonRepository.findOne({
- person: request.user['id'],
- game: gameId,
+ where: { person: request.user['id'], game: gameId },
+ relations: ['faction', 'group'],
});
+ // add gameperson role to the request
+ // @GamePerson decorator can access it and pass it to service
+ request.gameperson = role;
// check that the role matches the criteria and that token is valid for this game
return role && roles.includes(role['role']);
}
diff --git a/src/shared/states.guard.ts b/src/shared/states.guard.ts
index 9e85e94e40f92ed6b016e451c592a3025a684cad..544918d56e4653f6d52950a06ee8abd3e0eea4f1 100644
--- a/src/shared/states.guard.ts
+++ b/src/shared/states.guard.ts
@@ -8,9 +8,17 @@ import {
import { Reflector } from '@nestjs/core';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
+import { Validator } from 'class-validator';
import { GameEntity } from '../game/game.entity';
+//////////////////////////////////////////////////////////
+/// https://docs.nestjs.com/guards ///
+/// StatesGuard verifies the game's state ///
+/// Guard needs gameId as 'id' in request parameters ///
+/// return 400 if state if state validation fails ///
+//////////////////////////////////////////////////////////
+
@Injectable()
export class StatesGuard implements CanActivate {
constructor(
@@ -29,6 +37,12 @@ export class StatesGuard implements CanActivate {
}
const request = context.switchToHttp().getRequest();
const gameId = request.params.id;
+ // create a valifator
+ const validator = new Validator();
+ // verify UUID
+ if (!validator.isUUID(gameId)) {
+ throw new HttpException('Game not found', HttpStatus.BAD_REQUEST);
+ }
const gameRef = await this.gameRepository.findOne({
id: gameId,
});
diff --git a/src/shared/validation.pipe.ts b/src/shared/validation.pipe.ts
index cff51f1b068b67886c29dd85587760a1fa016f1e..7e4bb8796f7b036c20238729b54f9c3d6093505c 100644
--- a/src/shared/validation.pipe.ts
+++ b/src/shared/validation.pipe.ts
@@ -7,7 +7,15 @@ import {
} from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';
-import { AdvancedConsoleLogger } from 'typeorm';
+
+///////////////////////////////////////////////////////////
+/// https://docs.nestjs.com/techniques/validation ///
+/// ValidationPipe for validating DTO's ///
+/// DTO's use ClassValidator which are ///
+/// validated by ValidationPipes ///
+/// return 400 if pipe validation fails with ///
+/// errorMessage stating reason for validation fail ///
+///////////////////////////////////////////////////////////
@Injectable()
export class ValidationPipe implements PipeTransform<any> {
diff --git a/src/task/task.controller.ts b/src/task/task.controller.ts
index 8283ba5bd2c4d7da4eb668ac6268d5165930e3f4..ba9f6cc9e9be2e6f8408c337ed270d0a587d2ba9 100644
--- a/src/task/task.controller.ts
+++ b/src/task/task.controller.ts
@@ -12,7 +12,7 @@ import { TaskService } from './task.service';
import { CreateTaskDTO, EditTaskDTO, DeleteTaskDTO } from './task.dto';
import { Roles } from '../shared/guard.decorator';
import { ValidationPipe } from '../shared/validation.pipe';
-import { User } from '../user/user.decorator';
+import { GamePerson } from 'src/game/gameperson.decorator';
@Controller('task')
export class TaskController {
@@ -42,14 +42,14 @@ export class TaskController {
@Roles('admin')
@UsePipes(new ValidationPipe())
async deleteTask(@Param('id') id: string, @Body() data: DeleteTaskDTO) {
- return this.taskService.deleteTask(data);
+ return this.taskService.deleteTask(data, id);
}
// lists all the tasks for the game if the user has game_person entry
// :id is the id of the game
@Get('get-tasks/:id')
@Roles('soldier', 'factionleader', 'admin')
- async fetchTasks(@User('id') person, @Param('id') id: string) {
- return this.taskService.fetchTasks(person, id);
+ async fetchTasks(@GamePerson() gameperson, @Param('id') id: string) {
+ return this.taskService.fetchTasks(gameperson, id);
}
}
diff --git a/src/task/task.dto.ts b/src/task/task.dto.ts
index a1576e7d12c9d9a6263b445fdba293fe94e8964a..02653c39d5762784215303956652aaec78c60f81 100644
--- a/src/task/task.dto.ts
+++ b/src/task/task.dto.ts
@@ -5,10 +5,10 @@ import {
Validate,
IsUUID,
Equals,
+ IsOptional,
} from 'class-validator';
import { FactionEntity } from '../faction/faction.entity';
import { GameEntity } from '../game/game.entity';
-import { Uuid } from '../shared/custom-validation';
export class CreateTaskDTO {
@IsString()
@@ -19,7 +19,8 @@ export class CreateTaskDTO {
taskDescription: string;
@IsBoolean()
taskIsActive: boolean;
- @Validate(Uuid)
+ @IsOptional()
+ @IsUUID('4')
faction: FactionEntity;
@Equals(null)
taskWinner: FactionEntity;
diff --git a/src/task/task.entity.ts b/src/task/task.entity.ts
index f1c1cf103fa4338a7f10d0305888d13c097d7a09..762dbc038992f394b1bd773b9fd4e2965fe9a145 100644
--- a/src/task/task.entity.ts
+++ b/src/task/task.entity.ts
@@ -16,6 +16,7 @@ export class TaskEntity {
@Column({ type: 'text' }) taskDescription: string;
@Column({ type: 'bool' }) taskIsActive: boolean;
+ // when a Faction or Game is deleted, affiliated Tasks are also deleted
@ManyToOne(type => FactionEntity, faction => faction.factionId, {
onDelete: 'CASCADE',
})
diff --git a/src/task/task.module.ts b/src/task/task.module.ts
index 66d5ac5fce93d8447317343283a84b5002755ab6..9b009fc9480aab4e6708a9d8a986447393b76634 100644
--- a/src/task/task.module.ts
+++ b/src/task/task.module.ts
@@ -5,12 +5,16 @@ import { TaskService } from './task.service';
import { TaskController } from './task.controller';
import { TaskEntity } from './task.entity';
import { FactionEntity } from '../faction/faction.entity';
-import { Game_PersonEntity } from '../game/game.entity';
import { NotificationModule } from '../notifications/notifications.module';
+/////////////////////////////////////////////////////////////////////
+/// Task ///
+/// - contains everything to do with Task data. ///
+/////////////////////////////////////////////////////////////////////
+
@Module({
imports: [
- TypeOrmModule.forFeature([TaskEntity, FactionEntity, Game_PersonEntity]),
+ TypeOrmModule.forFeature([TaskEntity, FactionEntity]),
NotificationModule,
],
controllers: [TaskController],
diff --git a/src/task/task.service.ts b/src/task/task.service.ts
index d79338e0d21e9ce741c67d4bf94b89ba64e4c9c9..0461d310de44f882ccdf18c4b2ba29f01cb5d8a7 100644
--- a/src/task/task.service.ts
+++ b/src/task/task.service.ts
@@ -5,7 +5,6 @@ import { InjectRepository } from '@nestjs/typeorm';
import { TaskEntity } from './task.entity';
import { CreateTaskDTO, EditTaskDTO, DeleteTaskDTO } from './task.dto';
import { FactionEntity } from '../faction/faction.entity';
-import { Game_PersonEntity } from '../game/game.entity';
import { NotificationGateway } from '../notifications/notifications.gateway';
@Injectable()
@@ -15,8 +14,6 @@ export class TaskService {
private taskRepository: Repository<TaskEntity>,
@InjectRepository(FactionEntity)
private factionRepository: Repository<FactionEntity>,
- @InjectRepository(Game_PersonEntity)
- private gamePersonRepository: Repository<Game_PersonEntity>,
private notificationGateway: NotificationGateway,
) {}
@@ -35,10 +32,7 @@ export class TaskService {
await this.taskRepository.insert(createdTask);
// notify subscribers about a new task
// if faction was set it notifies only faction members, else everyone
- this.notificationGateway.server.emit(
- task.faction != null ? task.faction.toString() : task.taskGame.toString(),
- { type: 'task-update' },
- );
+ this.triggerTasks(task, task.taskGame);
return {
message: 'Task added',
};
@@ -62,15 +56,17 @@ export class TaskService {
task.taskWinner = data.taskWinner;
task.taskIsActive = false;
await this.taskRepository.save(task);
+ this.triggerTasks(task, data.taskGame);
return {
message: 'Task updated and closed',
};
}
- async deleteTask(data: DeleteTaskDTO) {
+ async deleteTask(data: DeleteTaskDTO, gameId) {
const task = await this.taskRepository.findOne({ taskId: data.taskId });
if (task) {
await this.taskRepository.delete({ taskId: task.taskId });
+ this.triggerTasks(task, gameId);
return {
message: 'Task deleted',
};
@@ -78,15 +74,17 @@ export class TaskService {
throw new HttpException('Task not found', HttpStatus.BAD_REQUEST);
}
- async fetchTasks(user, taskGame) {
- const gamePerson = await this.gamePersonRepository.findOne({
- where: {
- person: user,
- game: taskGame,
- },
- relations: ['faction'],
+ private triggerTasks(task, gameId) {
+ this.notificationGateway.server.emit(gameId, {
+ type: 'task-update',
+ message: task.faction != null ? task.faction.toString() : '',
});
- if (gamePerson.role == 'admin') {
+ }
+
+ // finds all tasks if admin and if non-admin player it finds the playres own
+ // tasks and general tasks
+ async fetchTasks(gameperson, taskGame) {
+ if (gameperson.role == 'admin') {
return await this.taskRepository.find({
where: { taskGame: taskGame },
relations: ['faction', 'taskWinner'],
@@ -97,7 +95,7 @@ export class TaskService {
where: [
{
taskGame: taskGame,
- faction: gamePerson.faction.factionId,
+ faction: gameperson.faction.factionId,
},
{
taskGame: taskGame,
diff --git a/src/tick/tick.module.ts b/src/tick/tick.module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b07fa5fa1eca4c4357d6e551983edf1b5c3aebe6
--- /dev/null
+++ b/src/tick/tick.module.ts
@@ -0,0 +1,32 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import {
+ GameEntity,
+ ObjectivePointEntity,
+ ObjectivePoint_HistoryEntity,
+} from '../game/game.entity';
+import { TickService } from './tick.service';
+import { ScoreService } from '../score/score.service';
+import { FactionEntity } from '../faction/faction.entity';
+import { ScoreEntity } from '../score/score.entity';
+import { NotificationModule } from '../notifications/notifications.module';
+
+@Module({
+ imports: [
+ TypeOrmModule.forFeature([
+ GameEntity,
+ ScoreEntity,
+ ObjectivePointEntity,
+ ObjectivePoint_HistoryEntity,
+ FactionEntity,
+ ]),
+ NotificationModule,
+ ],
+ providers: [TickService, ScoreService],
+})
+export class TickModule {
+ constructor(private tickService: TickService) {
+ this.tickService.startTimer();
+ }
+}
diff --git a/src/tick/tick.service.ts b/src/tick/tick.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3a5f7cc1dac03303eaf0febcba0cd603fdeaf45a
--- /dev/null
+++ b/src/tick/tick.service.ts
@@ -0,0 +1,50 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ScoreService } from '../score/score.service';
+import { InjectRepository } from '@nestjs/typeorm';
+import { GameEntity } from 'src/game/game.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class TickService {
+ constructor(
+ private scoreService: ScoreService,
+ @InjectRepository(GameEntity)
+ private gameRepository: Repository<GameEntity>,
+ ) {
+ // whenever Tickservice is called, it will start ticktimer
+ /*
+ WARNING: multiple calls start multiple timers,
+ if you need to use this service somewhere else remember to call startTimer method from somewhere else
+ */
+ }
+
+ private logger: Logger = new Logger('TickLogger');
+ // tickinterval in milliseconds (10 minutes = 600 000)
+ private readonly tickInterval: number = 60000;
+
+ // initializing timer
+ async startTimer() {
+ this.logger.log('Started timer');
+ setInterval(this.Tick, this.tickInterval);
+ }
+
+ // returns name and id of each game
+ async listGames() {
+ const games = await this.gameRepository.find({
+ where: { state: 'STARTED' },
+ });
+ return games.map(game => {
+ return game.gameObject();
+ });
+ }
+
+ // tick score for games with STARTED-status
+ Tick = async _ => {
+ this.logger.log('Ticking');
+ let games = await this.listGames();
+ games.map(game => {
+ this.logger.log(game);
+ this.scoreService.scoreTick(game.id);
+ });
+ };
+}
diff --git a/src/tracking/geo.dto.ts b/src/tracking/geo.dto.ts
index 352faf704db72912a548734185d277253d67c789..681e1b6d1f5c4cc30d66e113b5d1fb0dbf653dd9 100644
--- a/src/tracking/geo.dto.ts
+++ b/src/tracking/geo.dto.ts
@@ -1,5 +1,7 @@
import { IsNumber, Min, Max, Allow } from 'class-validator';
+// latitude and longitude accepts degrees from worldmap
+
export class GeoDTO {
@IsNumber()
@Min(-90)
diff --git a/src/tracking/tracking.controller.ts b/src/tracking/tracking.controller.ts
index ca0e79ee5195503f61d827dbc170474e66fd1bad..a98c12bfb399cc797c9dd642de2663ae5d0a5d76 100644
--- a/src/tracking/tracking.controller.ts
+++ b/src/tracking/tracking.controller.ts
@@ -2,18 +2,19 @@ import {
Controller,
Post,
Param,
- UseGuards,
UsePipes,
Body,
Get,
+ UseInterceptors,
+ ClassSerializerInterceptor,
} from '@nestjs/common';
import { TrackingService } from './tracking.service';
-import { TrackingDTO } from './tracking.dto';
import { User } from '../user/user.decorator';
import { Roles, GameStates } from '../shared/guard.decorator';
import { ValidationPipe } from '../shared/validation.pipe';
import { GeoDTO } from './geo.dto';
+import { GamePerson } from '../game/gameperson.decorator';
@Controller('tracking')
export class TrackingController {
@@ -26,17 +27,19 @@ export class TrackingController {
@GameStates('STARTED')
@UsePipes(new ValidationPipe())
async trackLocation(
- @User('id') userId,
+ @GamePerson() gameperson,
@Param('id') id,
@Body() trackdata: GeoDTO,
) {
- return this.trackingservice.trackLocation(userId, id, trackdata);
+ return this.trackingservice.trackLocation(gameperson, id, trackdata);
}
+ // finds certain player's location
+ // :id is the id of the game
@Get('players/:id')
@Roles('admin', 'factionleader')
@GameStates('STARTED', 'PAUSED')
- async getPlayerLocations(@User('id') userId, @Param('id') gameId) {
- return this.trackingservice.getPlayers(userId, gameId);
+ async getPlayerLocations(@GamePerson() gameperson, @Param('id') gameId) {
+ return this.trackingservice.getPlayers(gameperson, gameId);
}
}
diff --git a/src/tracking/tracking.dto.ts b/src/tracking/tracking.dto.ts
index 81cc71597fa93910cb195b1fd4e30f38c62c1f05..181430ba1f631fda4202d9d5115247a27c82a99c 100644
--- a/src/tracking/tracking.dto.ts
+++ b/src/tracking/tracking.dto.ts
@@ -1,5 +1,4 @@
-import { Game_PersonEntity } from '../game/game.entity';
-import { Allow, ValidateNested } from 'class-validator';
+import { ValidateNested } from 'class-validator';
import { GeoDTO } from './geo.dto';
import { Type } from 'class-transformer';
diff --git a/src/tracking/tracking.entity.ts b/src/tracking/tracking.entity.ts
index c2699a09388ce8ad47c7119b46f4614fa52b34ec..dc398ac8d9398aa475de128fd2bc6bfb87074013 100644
--- a/src/tracking/tracking.entity.ts
+++ b/src/tracking/tracking.entity.ts
@@ -1,13 +1,15 @@
import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { Game_PersonEntity, GameEntity } from '../game/game.entity';
-import { FactionEntity } from 'src/faction/faction.entity';
+import { FactionEntity } from '../faction/faction.entity';
import { GeoDTO } from './geo.dto';
@Entity('Tracking')
export class TrackingEntity {
@PrimaryGeneratedColumn('uuid') id: string;
@Column({ type: 'json', nullable: true }) data: GeoDTO[];
+ @Column('text') icon: string;
+ // when the GamePerson is deleted it's tracking data is also deleted
@ManyToOne(type => Game_PersonEntity, person => person.gamepersonId, {
onDelete: 'CASCADE',
})
diff --git a/src/tracking/tracking.module.ts b/src/tracking/tracking.module.ts
index 45b167fc526ab41addbb87575518c9acae884482..de4afda4d1450da298902942709df1f039adc024 100644
--- a/src/tracking/tracking.module.ts
+++ b/src/tracking/tracking.module.ts
@@ -5,9 +5,23 @@ import { TrackingController } from './tracking.controller';
import { TrackingService } from './tracking.service';
import { TrackingEntity } from './tracking.entity';
import { Game_PersonEntity } from '../game/game.entity';
+import { PersonEntity } from '../user/user.entity';
+import { FactionEntity } from '../faction/faction.entity';
+
+/////////////////////////////////////////////////////////////////////
+/// Tracking ///
+/// - contains everything to do with Tracking data. ///
+/////////////////////////////////////////////////////////////////////
@Module({
- imports: [TypeOrmModule.forFeature([TrackingEntity, Game_PersonEntity])],
+ imports: [
+ TypeOrmModule.forFeature([
+ TrackingEntity,
+ Game_PersonEntity,
+ PersonEntity,
+ FactionEntity,
+ ]),
+ ],
controllers: [TrackingController],
providers: [TrackingService],
})
diff --git a/src/tracking/tracking.service.ts b/src/tracking/tracking.service.ts
index 9941256dde52240d7c90b45d61b7b32ef4e1c242..175c3eaaeb548507dc103c484b0f908edba9f1e1 100644
--- a/src/tracking/tracking.service.ts
+++ b/src/tracking/tracking.service.ts
@@ -1,13 +1,11 @@
-import { Injectable, HttpStatus, HttpException } from '@nestjs/common';
+import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Game_PersonEntity } from '../game/game.entity';
import { TrackingEntity } from './tracking.entity';
-import { TrackingDTO } from './tracking.dto';
-import { FactionEntity } from '../faction/faction.entity';
-import { NotificationGateway } from 'src/notifications/notifications.gateway';
import { GeoDTO } from './geo.dto';
+import { FactionEntity } from 'src/faction/faction.entity';
@Injectable()
export class TrackingService {
@@ -16,87 +14,111 @@ export class TrackingService {
private trackingrepository: Repository<TrackingEntity>,
@InjectRepository(Game_PersonEntity)
private gamepersonrepository: Repository<Game_PersonEntity>,
+ @InjectRepository(FactionEntity)
+ private factionRepository: Repository<FactionEntity>,
) {}
- async trackLocation(personId, gameId, trackdata: GeoDTO) {
- // find player
- let gameperson = await this.gamepersonrepository.findOne({
- where: { game: gameId, person: personId },
- relations: ['faction'],
- });
- if (!gameperson) {
- throw new HttpException(
- 'You have not joined this game',
- HttpStatus.BAD_REQUEST,
- );
- }
+ private icons = {
+ infantry: 'infantry.svg',
+ recon: 'recon.svg',
+ mechanized: 'mechanized.svg',
+ };
+
+ async trackLocation(
+ gameperson: Game_PersonEntity,
+ gameId,
+ trackdata: GeoDTO,
+ ) {
+ // find ref to gameperson's tracking data
let trackedperson = await this.trackingrepository.findOne({
gamepersonId: gameperson,
});
- // if player has pushed tracking data, update entry
if (trackedperson) {
trackdata['time'] = Date.now();
//add coordinates
trackedperson.data.push(trackdata);
//add timestamp
await this.trackingrepository.save(trackedperson);
- return { code: 201, message: 'Location updated!' };
+ return { message: 'Location updated!' };
} else {
- // first entry will be empty
trackdata['time'] = Date.now();
// initialize data
trackedperson = await this.trackingrepository.create(trackedperson);
+ // if group exists, add icon based on that, else add default icon
+ trackedperson.icon = gameperson.group
+ ? this.icons[gameperson.group.class]
+ : 'infantry.svg';
trackedperson.data = [trackdata];
trackedperson.faction = gameperson.faction;
trackedperson.game = gameId;
trackedperson.gamepersonId = gameperson;
await this.trackingrepository.save(trackedperson);
- return { code: 201, message: 'Entry Created!' };
+ return { message: 'Entry Created!' };
}
}
// get player data while game is running
- async getPlayers(userId, gameId) {
- // get gameperson
- const gameperson = await this.gamepersonrepository.findOne({
- where: { person: userId, game: gameId },
- relations: ['faction'],
- });
-
- let playerdata;
+ async getPlayers(gameperson, gameId) {
+ let playerdata = [];
// get playerdata
if (gameperson.faction) {
- playerdata = await this.trackingrepository.find({
- where: { faction: gameperson.faction },
- relations: ['faction', 'gamepersonId'],
- });
+ // create an array of the response as frontend maps the response
+ // to create different clusters for factions
+ playerdata.push(
+ await this.trackingrepository.find({
+ where: { faction: gameperson.faction },
+ relations: ['faction', 'gamepersonId', 'gamepersonId.person'],
+ }),
+ );
} else {
- playerdata = await this.trackingrepository.find({
- where: { game: gameId },
- relations: ['faction', 'gamepersonId'],
- });
+ let factions = await this.factionRepository.find({ game: gameId });
+ playerdata = await Promise.all(
+ factions.map(async faction => {
+ let rawdata = await this.trackingrepository.find({
+ where: { faction: faction.factionId },
+ relations: ['faction', 'gamepersonId', 'gamepersonId.person'],
+ });
+ let groups = {
+ 'infantry.svg': [],
+ 'recon.svg': [],
+ 'mechanized.svg': [],
+ };
+ rawdata.forEach(async player => {
+ groups[player.icon].push(player);
+ });
+ return groups;
+ }),
+ );
}
-
// parse data
+ // create an array for each faction
+ // inside faction create an array for each icon type
+ // insisde icon arrays include all players with same icon
const currentdata = await Promise.all(
- playerdata.map(async player => {
- return {
- gamepersonId: player['gamepersonId']['gamepersonId'],
- gamepersonRole: player['gamepersonId']['role'],
- factionId: player['faction']['factionId'],
- coordinates: player['data'].pop(),
- };
+ await playerdata.map(async faction => {
+ let data = [];
+ for (let group in faction) {
+ data.push(
+ await Promise.all(
+ faction[group].map(async player => {
+ return await {
+ username: player['gamepersonId']['person']['name'],
+ gamepersonId: player['gamepersonId']['gamepersonId'],
+ gamepersonRole: player['gamepersonId']['role'],
+ factionId: player['faction']['factionId'],
+ factionColour: player['faction']['colour'],
+ icon: player['icon'],
+ coordinates: player['data'].pop(),
+ };
+ }),
+ ),
+ );
+ }
+ return data;
}),
);
-
return currentdata;
}
-
- private async mapFunction(data): Promise<Number> {
- return await data.map(type => {
- return type;
- });
- }
}
diff --git a/src/user/user.controller.ts b/src/user/user.controller.ts
index 4d4158d3f037850c8c5230975ef5f46ae5a75ede..8e7635767424c627f8372d8b312cc2b7229e673a 100644
--- a/src/user/user.controller.ts
+++ b/src/user/user.controller.ts
@@ -12,6 +12,16 @@ import { UserDTO } from './user.dto';
import { AuthGuard } from '../shared/auth.guard';
import { ValidationPipe } from '../shared/validation.pipe';
+/////////////////////////////////////////////////////////////////////
+/// UserController is being used for routing: ///
+/// - Login ///
+/// - Register ///
+/// ///
+/// - Verify is checking for logged in user ///
+/// ///
+/// See shared folder files for more information on decorators. ///
+/////////////////////////////////////////////////////////////////////
+
@Controller('user')
export class UserController {
constructor(private userService: UserService) {}
diff --git a/src/user/user.decorator.ts b/src/user/user.decorator.ts
index 2c499d904927d0502567fc2131270b81170327f4..4a6ec4788ceb7698d57d6c7986dd98d11e1dae31 100644
--- a/src/user/user.decorator.ts
+++ b/src/user/user.decorator.ts
@@ -1,6 +1,14 @@
-import { createParamDecorator } from "@nestjs/common";
+import { createParamDecorator } from '@nestjs/common';
+
+///////////////////////////////////////////////////////////////////////////////
+/// UserDecorator ///
+/// ///
+/// See auth.guard.ts in shared folder for more information ///
+/// ///
+/// Returns user id and user name, this is mainly used to return user id ///
+///////////////////////////////////////////////////////////////////////////////
// used to pass user information to controllers
export const User = createParamDecorator((data, req) => {
- return data ? req.user[data] : req.user;
-})
\ No newline at end of file
+ return data ? req.user[data] : req.user;
+});
diff --git a/src/user/user.dto.ts b/src/user/user.dto.ts
index c5bfa70cc3551645e1773e9aa7c4fb898b3f9887..243dae1faa53acc3c9a6a051db32b1a20b1728d3 100644
--- a/src/user/user.dto.ts
+++ b/src/user/user.dto.ts
@@ -1,10 +1,18 @@
import { IsString, IsNotEmpty, Length } from 'class-validator';
+///////////////////////////////////////////////////////////
+/// Contains Validation for UserDTO ///
+/// uses class-validator built in validations ///
+/// see https://github.com/typestack/class-validator ///
+///////////////////////////////////////////////////////////
+
export class UserDTO {
- // uses class-validator built in validations
- // see https://github.com/typestack/class-validator
- @IsString() @IsNotEmpty() @Length(3, 31)
- name: string;
- @IsString() @IsNotEmpty() @Length(3, 255)
- password: string;
-}
\ No newline at end of file
+ @IsString()
+ @IsNotEmpty()
+ @Length(3, 31)
+ name: string;
+ @IsString()
+ @IsNotEmpty()
+ @Length(3, 255)
+ password: string;
+}
diff --git a/src/user/user.entity.ts b/src/user/user.entity.ts
index 716020ae49d675641863a1711e424b85dbd67608..1c4c8d9eb7a38f6fb1f8003a6c5cd7a02d44d339 100644
--- a/src/user/user.entity.ts
+++ b/src/user/user.entity.ts
@@ -11,6 +11,15 @@ import * as jwt from 'jsonwebtoken';
import { Game_PersonEntity } from '../game/game.entity';
import { Exclude } from 'class-transformer';
+/////////////////////////////////////////////////////////////////////////////
+/// UserEntity reflects database table. ///
+/// ///
+/// Before handling password to database we encrypt it with bcrypt. ///
+/// password field will be excluded unless we call repository relation. ///
+/// ///
+/// token will be created when user registers or logs in to the system. ///
+/////////////////////////////////////////////////////////////////////////////
+
@Entity('Person')
export class PersonEntity {
@PrimaryGeneratedColumn('uuid') id: string;
@@ -39,6 +48,7 @@ export class PersonEntity {
return await bcrypt.compareSync(attempt, this.password);
}
+ // creates token from id and name, it will be created through jsonwebtoken and .env SECRET field
private get token() {
const { id, name } = this;
return jwt.sign(
diff --git a/src/user/user.module.ts b/src/user/user.module.ts
index 6cb77a7b735df532d710febc33a4df53f264563a..85ec0ffd05dff0bd401da8d2807ed81ddbafdd57 100644
--- a/src/user/user.module.ts
+++ b/src/user/user.module.ts
@@ -3,11 +3,21 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { UserController } from './user.controller';
import { UserService } from './user.service';
-import { PersonEntity} from './user.entity';
-import { GameEntity } from '../game/game.entity';
+import { PersonEntity } from './user.entity';
+
+///////////////////////////
+/// Entities ///
+/// - PersonEntity ///
+/// ///
+/// Controllers ///
+/// - UserController ///
+/// ///
+/// Provider ///
+/// - UserService ///
+///////////////////////////
@Module({
- imports: [TypeOrmModule.forFeature([PersonEntity, GameEntity])],
+ imports: [TypeOrmModule.forFeature([PersonEntity])],
controllers: [UserController],
providers: [UserService],
})
diff --git a/src/user/user.service.ts b/src/user/user.service.ts
index aa511e27802548a17449e7912144598e7eda3732..5e05634bb81e51d45d3241f3cb4d1fdfc26ee1b9 100644
--- a/src/user/user.service.ts
+++ b/src/user/user.service.ts
@@ -4,16 +4,23 @@ import { InjectRepository } from '@nestjs/typeorm';
import { PersonEntity } from './user.entity';
import { UserDTO } from './user.dto';
-import { GameEntity } from '../game/game.entity';
-import { GameDTO } from '../game/game.dto';
+
+///////////////////////////////////////////////////////////
+/// UserService contains functions for ///
+/// - Login ///
+/// - Register ///
+/// ///
+/// Both functions return logged in users tokenObject ///
+/// See more info in UserEntity. ///
+/// ///
+/// See more info on DTO in it's respective file ///
+///////////////////////////////////////////////////////////
@Injectable()
export class UserService {
constructor(
@InjectRepository(PersonEntity)
private userRepository: Repository<PersonEntity>,
- @InjectRepository(GameEntity)
- private gameRepository: Repository<GameEntity>,
) {}
async register(data: UserDTO) {
@@ -38,25 +45,4 @@ export class UserService {
}
return user.tokenObject();
}
-
- // liitytään peliin
- async joinGame(game: GameDTO, data: UserDTO) {
- try {
- // etsi peli valinnan mukaan ja otetaan käyttäjän rooli kyseisestä pelistä talteen
- const role = await this.gameRepository.findOne();
- return role;
- } catch (error) {
- return error.message;
- }
- }
-
- // liitytään factionii
- async joinFaction(game: GameDTO, data: UserDTO): Promise<boolean> {
- try {
- // tarkistetaan factionin salasana
- return true;
- } catch (error) {
- return error;
- }
- }
}