feature(database-connection): First implementation

backend/src/database/database.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DatabaseService } from './database.service';
+
+describe('DatabaseService', () => {
+  let service: DatabaseService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [DatabaseService],
+    }).compile();
+
+    service = module.get<DatabaseService>(DatabaseService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/database/database.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+import logger from 'src/logger/Logger';
+import { TableEntry } from 'src/models/TableEntry';
+import { TimeTrackerPredicate } from './timetracking.predicate';
+
+@Injectable()
+export class DatabaseService {
+    // private host = process.env.MYSQL_HOST
+    // private port = process.env.MYSQL_PORT
+    // private credentials = {
+    //   username: process.env.MYSQL_USERNAME,
+    //   password: process.env.MYSQL_PASSWORD
+    // }
+    // private database = process.env.MYSQL_DATABASE
+
+    constructor(
+        private readonly prismaClient: PrismaClient,
+        private readonly timetrackerPredicate: TimeTrackerPredicate
+    ) {}
+
+    public fetchStats(): Promise<TableEntry[]> {
+        return new Promise((resolve, reject) => {
+            this.prismaClient.timetracker.findMany({
+                include: {
+                    user: true,
+                    ranks: true
+                }
+            })
+            .then(this.timetrackerPredicate.process)
+            .then(result => resolve(result))
+            .catch(err => reject(err));
+        });
+    }
+}

backend/src/database/timetracking.predicate.ts

@@ -0,0 +1,23 @@
+import { ranks, seasons, timetracker, user } from "@prisma/client";
+import { Predicate } from "src/api/predicate";
+import { Sort } from "src/api/sort";
+import { TimeUtil } from "src/api/timeutil";
+import { TableEntry } from "src/models/TableEntry";
+
+type UserStats = timetracker & { user: user, ranks: ranks; };
+
+export class TimeTrackerPredicate implements Predicate<UserStats[], TableEntry[]> {
+
+    process(input: UserStats[]): TableEntry[] {
+        return input.filter((userStats: UserStats) => userStats.time != null)
+            .map((userStats: UserStats) => {
+                return {
+                    name: userStats.user.name,
+                    rawTime: userStats.time,
+                    onlineTime: TimeUtil.humanize(userStats.time),
+                    rank: userStats.ranks.rank_name
+                }
+            })
+            .sort((lhs, rhs) => Sort.descending(lhs.rawTime, rhs.rawTime));
+    }
+}