data persistance init

src/ORM/client-statistics/client-statistics.entity.ts

@@ -0,0 +1,24 @@
+import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+
+import { ClientEntity } from '../client/client.entity';
+
+@Entity()
+export class ClientStatisticsEntity {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({ type: 'datetime' })
+    time: Date;
+
+    @Column()
+    difficulty: number;
+
+
+    @ManyToOne(
+        () => ClientEntity,
+        client => client.clientStatistics
+    )
+    client: ClientEntity;
+
+}

src/ORM/client-statistics/client-statistics.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ClientStatisticsEntity } from './client-statistics.entity';
+import { ClientStatisticsService } from './client-statistics.service';
+
+
+@Global()
+@Module({
+    imports: [TypeOrmModule.forFeature([ClientStatisticsEntity])],
+    providers: [ClientStatisticsService],
+    exports: [TypeOrmModule, ClientStatisticsService],
+})
+export class ClientStatisticsModule { }

src/ORM/client-statistics/client-statistics.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { ClientStatisticsEntity } from './client-statistics.entity';
+
+
+@Injectable()
+export class ClientStatisticsService {
+
+    constructor(
+        @InjectRepository(ClientStatisticsEntity)
+        private clientStatisticsRepository: Repository<ClientStatisticsEntity>
+    ) {
+
+    }
+
+    public async save(clientStatistic: Partial<ClientStatisticsEntity>) {
+        return await this.clientStatisticsRepository.save(clientStatistic);
+    }
+
+    public async getHashRate(clientId: string) {
+
+        const query = `
+            SELECT
+            (JULIANDAY(MAX(entry.time)) - JULIANDAY(MIN(entry.time))) * 24 * 60 * 60 AS timeDiff,
+            SUM(entry.difficulty) AS difficultySum
+        FROM
+            client_statistics_entity AS entry
+        WHERE
+            entry.clientId = ?
+        `;
+
+        const result = await this.clientStatisticsRepository.query(query, [clientId]);
+
+        const timeDiff = result[0].timeDiff;
+        const difficultySum = result[0].difficultySum;
+
+        return (difficultySum * 4294967296) / (timeDiff * 1000000000);
+
+    }
+}

src/ORM/client/client.entity.ts

@@ -0,0 +1,29 @@
+import { Column, Entity, OneToMany, PrimaryColumn } from 'typeorm';
+
+import { ClientStatisticsEntity } from '../client-statistics/client-statistics.entity';
+import { TrackedEntity } from '../utils/TrackedEntity.entity';
+
+@Entity()
+export class ClientEntity extends TrackedEntity {
+    @PrimaryColumn({ length: 8, type: 'varchar' })
+    id: string;
+
+    @Column({ type: 'datetime' })
+    startTime: Date;
+
+    @Column()
+    clientName: string;
+
+    @Column({ length: 62, type: 'varchar' })
+    address: string;
+
+    @Column({ default: 0 })
+    bestDifficulty: number
+
+    @OneToMany(
+        () => ClientStatisticsEntity,
+        clientStatistic => clientStatistic.client
+    )
+    clientStatistics?: ClientStatisticsEntity[];
+
+}

src/ORM/client/client.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ClientEntity } from './client.entity';
+import { ClientService } from './client.service';
+
+
+@Global()
+@Module({
+    imports: [TypeOrmModule.forFeature([ClientEntity])],
+    providers: [ClientService],
+    exports: [TypeOrmModule, ClientService],
+})
+export class ClientModule { }

src/ORM/client/client.service.ts

@@ -0,0 +1,51 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { ClientEntity } from './client.entity';
+
+
+
+
+@Injectable()
+export class ClientService {
+
+    constructor(
+        @InjectRepository(ClientEntity)
+        private clientRepository: Repository<ClientEntity>
+    ) {
+
+    }
+
+    public async save(client: Partial<ClientEntity>) {
+        return await this.clientRepository.save(client);
+    }
+
+    public async delete(id: string) {
+        return await this.clientRepository.softDelete({ id });
+    }
+
+    public async updateBestDifficulty(id: string, bestDifficulty: number) {
+        return await this.clientRepository.update(id, { bestDifficulty });
+    }
+    public async connectedClientCount(): Promise<number> {
+        return await this.clientRepository.count();
+    }
+
+    public async getByAddress(address: string): Promise<ClientEntity[]> {
+        return await this.clientRepository.find({
+            where: {
+                address
+            }
+        })
+    }
+
+    public async getByAddressAndName(address: string, id: string): Promise<ClientEntity> {
+        return await this.clientRepository.findOne({
+            where: {
+                address,
+                id
+            }
+        })
+    }
+}

src/ORM/utils/TrackedEntity.entity.ts

@@ -0,0 +1,12 @@
+import { CreateDateColumn, DeleteDateColumn, UpdateDateColumn } from 'typeorm';
+
+export abstract class TrackedEntity {
+    @DeleteDateColumn({ nullable: true, type: 'datetime' })
+    public deletedAt?: Date;
+
+    @CreateDateColumn({ type: 'datetime' })
+    public createdAt?: Date
+
+    @UpdateDateColumn({ type: 'datetime' })
+    public updatedAt?: Date
+}