bastian/teamwallet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Bastian Wagner
2026-07-31 21:02:47 +02:00
commit 6bea4f766a
512 changed files with 64459 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
myteamwallet_backend/src/database/data-source.ts Normal file
View File

@@ -0,0 +1,23 @@
import 'reflect-metadata';
import { DataSource, DataSourceOptions } from 'typeorm';
export const AppDataSource = new DataSource({
type: process.env.DATABASE_TYPE,
url: process.env.DATABASE_URL,
host: process.env.DATABASE_HOST,
port: parseInt(process.env.DATABASE_PORT, 10) || 5432,
username: process.env.DATABASE_USERNAME,
password: process.env.DATABASE_PASSWORD,
database: process.env.DATABASE_NAME,
synchronize: process.env.DATABASE_SYNCHRONIZE === 'true',
dropSchema: false,
keepConnectionAlive: true,
logging: process.env.NODE_ENV !== 'production',
entities: [__dirname + '/../**/*.entity{.ts,.js}'],
migrations: [__dirname + '/migrations/**/*{.ts,.js}'],
cli: {
entitiesDir: 'src',
migrationsDir: 'src/database/migrations',
subscribersDir: 'subscriber',
},
} as DataSourceOptions);

13
myteamwallet_backend/src/database/logging/dto/create-log.dto.ts Normal file
View File

@@ -0,0 +1,13 @@
import { LOGEVENT, LOGLEVEL } from '../model/logging-event.type';
export class CreateLogDTO {
level: LOGLEVEL;
event: LOGEVENT;
details: string;
userId: number;
duration?: number;
}

39
myteamwallet_backend/src/database/logging/entities/log-entry.entity.ts Normal file
View File

@@ -0,0 +1,39 @@
import {
Column,
CreateDateColumn,
Entity,
PrimaryGeneratedColumn,
} from 'typeorm';
import { ApiProperty } from '@nestjs/swagger';
import { EntityHelper } from 'src/utils/entity-helper';
import { LOGEVENT, LOGLEVEL } from '../model/logging-event.type';
@Entity()
export class LogEntry extends EntityHelper {
@ApiProperty({ example: 1 })
@PrimaryGeneratedColumn()
id: number;
@ApiProperty({ example: 'error' })
@Column()
level: LOGLEVEL;
@ApiProperty({ example: 'created new user' })
@Column()
event: LOGEVENT;
@ApiProperty({ example: 'created new user max mustermann' })
@Column()
details: string;
@ApiProperty({ example: 5 })
@Column()
userId: number;
@ApiProperty({ example: 5 })
@Column({ nullable: true })
duration?: number;
@CreateDateColumn()
createdAt: Date;
}

11
myteamwallet_backend/src/database/logging/logging.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { LogEntry } from './entities/log-entry.entity';
import { LoggingService } from './logging.service';
@Module({
imports: [TypeOrmModule.forFeature([LogEntry])],
providers: [LoggingService],
exports: [LoggingService],
})
export class LoggingModule {}

18
myteamwallet_backend/src/database/logging/logging.service.spec.ts Normal file
View File

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

95
myteamwallet_backend/src/database/logging/logging.service.ts Normal file
View File

@@ -0,0 +1,95 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateLogDTO } from './dto/create-log.dto';
import { LogEntry } from './entities/log-entry.entity';
import { LOGEVENT } from './model/logging-event.type';
@Injectable()
export class LoggingService {
constructor(
@InjectRepository(LogEntry)
private repository: Repository<LogEntry>,
) {
// void this.onStart();
}
private async onStart() {
await this.repository.save({
level: 'DEBUG',
event: 'application_start',
details: 'application started',
userId: -1,
});
}
async info({
event,
details,
userId,
}: {
event: LOGEVENT;
details: string;
userId: number;
}) {
const e: CreateLogDTO = {
event,
details,
userId,
level: 'INFO',
};
await this.repository.save(e);
}
async error({
event,
details,
userId,
}: {
event: LOGEVENT;
details: string;
userId: number;
}) {
const e: CreateLogDTO = {
event,
details,
userId,
level: 'ERROR',
};
await this.repository.save(e);
}
async warn({
event,
details,
userId,
}: {
event: LOGEVENT;
details: string;
userId: number;
}) {
const e: CreateLogDTO = {
event,
details,
userId,
level: 'WARN',
};
await this.repository.save(e);
}
async debug(data: {
event: LOGEVENT;
details: string;
userId: number;
duration?: number;
}) {
const e: CreateLogDTO = {
event: data.event,
details: data.details,
userId: data.userId,
level: 'DEBUG',
duration: data.duration,
};
await this.repository.save(e);
}
}

5
myteamwallet_backend/src/database/logging/model/log-type.enum.ts Normal file
View File

@@ -0,0 +1,5 @@
export enum LogTypeEnum {
'error' = 1,
'info' = 2,
'warn' = 3,
}

20
myteamwallet_backend/src/database/logging/model/logging-event.type.ts Normal file
View File

@@ -0,0 +1,20 @@
export type LOGEVENT =
| 'user_create'
| 'application_start'
| 'transaction_create'
| 'team_transaction_create'
| 'team_transaction_get'
| 'user_login_success'
| 'user_login_fail'
| 'user_token_verification_success'
| 'user_token_verification_fail'
| 'user_invite_link_create'
| 'user_invite_link_validate'
| 'user_invite_link_validate_fail'
| 'transaction_create'
| 'transaction_create_fail'
| 'transaction_reverse'
| 'player_creation'
| 'team_create';
export type LOGLEVEL = 'FATAL' | 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE';

75
myteamwallet_backend/src/database/migrations/1604164774154-CreateUser.ts Normal file
View File

@@ -0,0 +1,75 @@
import { MigrationInterface, QueryRunner } from 'typeorm';
export class CreateUser1604164774154 implements MigrationInterface {
name = 'CreateUser1604164774154';
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(
`CREATE TABLE "file" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "path" character varying NOT NULL, CONSTRAINT "PK_36b46d232307066b3a2c9ea3a1d" PRIMARY KEY ("id"))`,
);
await queryRunner.query(
`CREATE TABLE "role" ("id" integer NOT NULL, "name" character varying NOT NULL, CONSTRAINT "PK_b36bcfe02fc8de3c57a8b2391c2" PRIMARY KEY ("id"))`,
);
await queryRunner.query(
`CREATE TABLE "status" ("id" integer NOT NULL, "name" character varying NOT NULL, CONSTRAINT "PK_e12743a7086ec826733f54e1d95" PRIMARY KEY ("id"))`,
);
await queryRunner.query(
`CREATE TABLE "user" ("id" SERIAL NOT NULL, "email" character varying, "password" character varying, "provider" character varying NOT NULL DEFAULT 'email', "socialId" character varying, "firstName" character varying, "lastName" character varying, "hash" character varying, "createdAt" TIMESTAMP NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP, "photoId" uuid, "roleId" integer, "statusId" integer, CONSTRAINT "UQ_e12875dfb3b1d92d7d7c5377e22" UNIQUE ("email"), CONSTRAINT "PK_cace4a159ff9f2512dd42373760" PRIMARY KEY ("id"))`,
);
await queryRunner.query(
`CREATE INDEX "IDX_9bd2fe7a8e694dedc4ec2f666f" ON "user" ("socialId") `,
);
await queryRunner.query(
`CREATE INDEX "IDX_58e4dbff0e1a32a9bdc861bb29" ON "user" ("firstName") `,
);
await queryRunner.query(
`CREATE INDEX "IDX_f0e1b4ecdca13b177e2e3a0613" ON "user" ("lastName") `,
);
await queryRunner.query(
`CREATE INDEX "IDX_e282acb94d2e3aec10f480e4f6" ON "user" ("hash") `,
);
await queryRunner.query(
`CREATE TABLE "forgot" ("id" SERIAL NOT NULL, "hash" character varying NOT NULL, "createdAt" TIMESTAMP NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP, "userId" integer, CONSTRAINT "PK_087959f5bb89da4ce3d763eab75" PRIMARY KEY ("id"))`,
);
await queryRunner.query(
`CREATE INDEX "IDX_df507d27b0fb20cd5f7bef9b9a" ON "forgot" ("hash") `,
);
await queryRunner.query(
`ALTER TABLE "user" ADD CONSTRAINT "FK_75e2be4ce11d447ef43be0e374f" FOREIGN KEY ("photoId") REFERENCES "file"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
);
await queryRunner.query(
`ALTER TABLE "user" ADD CONSTRAINT "FK_c28e52f758e7bbc53828db92194" FOREIGN KEY ("roleId") REFERENCES "role"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
);
await queryRunner.query(
`ALTER TABLE "user" ADD CONSTRAINT "FK_dc18daa696860586ba4667a9d31" FOREIGN KEY ("statusId") REFERENCES "status"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
);
await queryRunner.query(
`ALTER TABLE "forgot" ADD CONSTRAINT "FK_31f3c80de0525250f31e23a9b83" FOREIGN KEY ("userId") REFERENCES "user"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(
`ALTER TABLE "forgot" DROP CONSTRAINT "FK_31f3c80de0525250f31e23a9b83"`,
);
await queryRunner.query(
`ALTER TABLE "user" DROP CONSTRAINT "FK_dc18daa696860586ba4667a9d31"`,
);
await queryRunner.query(
`ALTER TABLE "user" DROP CONSTRAINT "FK_c28e52f758e7bbc53828db92194"`,
);
await queryRunner.query(
`ALTER TABLE "user" DROP CONSTRAINT "FK_75e2be4ce11d447ef43be0e374f"`,
);
await queryRunner.query(`DROP INDEX "IDX_df507d27b0fb20cd5f7bef9b9a"`);
await queryRunner.query(`DROP TABLE "forgot"`);
await queryRunner.query(`DROP INDEX "IDX_e282acb94d2e3aec10f480e4f6"`);
await queryRunner.query(`DROP INDEX "IDX_f0e1b4ecdca13b177e2e3a0613"`);
await queryRunner.query(`DROP INDEX "IDX_58e4dbff0e1a32a9bdc861bb29"`);
await queryRunner.query(`DROP INDEX "IDX_9bd2fe7a8e694dedc4ec2f666f"`);
await queryRunner.query(`DROP TABLE "user"`);
await queryRunner.query(`DROP TABLE "status"`);
await queryRunner.query(`DROP TABLE "role"`);
await queryRunner.query(`DROP TABLE "file"`);
}
}

29
myteamwallet_backend/src/database/migrations/1785513600000-AddTeamPublicAccess.ts Normal file
View File

@@ -0,0 +1,29 @@
import { MigrationInterface, QueryRunner } from 'typeorm';
export class AddTeamPublicAccess1785513600000 implements MigrationInterface {
name = 'AddTeamPublicAccess1785513600000';
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(
`ALTER TABLE "team" ADD "publicAccessEnabled" boolean NOT NULL DEFAULT false`,
);
await queryRunner.query(
`ALTER TABLE "team" ADD "publicAccessToken" character varying(64)`,
);
await queryRunner.query(
`ALTER TABLE "team" ADD CONSTRAINT "UQ_team_public_access_token" UNIQUE ("publicAccessToken")`,
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(
`ALTER TABLE "team" DROP CONSTRAINT "UQ_team_public_access_token"`,
);
await queryRunner.query(
`ALTER TABLE "team" DROP COLUMN "publicAccessToken"`,
);
await queryRunner.query(
`ALTER TABLE "team" DROP COLUMN "publicAccessEnabled"`,
);
}
}

13
myteamwallet_backend/src/database/seeds/player/player-seed.module.ts Normal file
View File

@@ -0,0 +1,13 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Player } from 'src/players/entities/player.entity';
import { Team } from 'src/teams/entities/team.entity';
import { User } from 'src/users/entities/user.entity';
import { PlayersSeedService } from './player-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([Player, Team, User])],
providers: [PlayersSeedService],
exports: [PlayersSeedService],
})
export class PlayersSeedModule {}

69
myteamwallet_backend/src/database/seeds/player/player-seed.service.ts Normal file
View File

@@ -0,0 +1,69 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Player } from 'src/players/entities/player.entity';
import { Team } from 'src/teams/entities/team.entity';
import { Repository } from 'typeorm';
import { faker } from '@faker-js/faker';
import { User } from 'src/users/entities/user.entity';
@Injectable()
export class PlayersSeedService {
constructor(
@InjectRepository(Player)
private repository: Repository<Player>,
@InjectRepository(Team)
private teamRepository: Repository<Team>,
@InjectRepository(User)
private userRepository: Repository<User>,
) {}
async run() {
const dev = await this.teamRepository.findOne({ where: { id: 1 } });
const countPlayer = await this.repository.count();
if (countPlayer === 0) {
const players = [];
for (let index = 0; index < 20; index++) {
const p = this.repository.create({
firstName: faker.name.firstName(),
lastName: faker.name.lastName(),
teamRole: {
id: 1,
name: 'player',
},
team: dev,
});
players.push(p);
}
const p2 = this.repository.create({
firstName: 'Player',
lastName: 'Kapitän',
teamRole: {
id: 3,
name: 'captain',
},
team: dev,
});
const u = await this.userRepository.findOne({
where: { email: 'mail@bastian-wagner.de' },
});
const p3 = this.repository.create({
firstName: 'Player',
lastName: 'Kassenwart',
teamRole: {
id: 4,
name: 'treasurer',
},
team: dev,
user: u,
});
await this.repository.save(players);
await this.repository.save([p2, p3]);
}
}
}

11
myteamwallet_backend/src/database/seeds/role/role-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Role } from 'src/roles/entities/role.entity';
import { RoleSeedService } from './role-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([Role])],
providers: [RoleSeedService],
exports: [RoleSeedService],
})
export class RoleSeedModule {}

45
myteamwallet_backend/src/database/seeds/role/role-seed.service.ts Normal file
View File

@@ -0,0 +1,45 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Role } from 'src/roles/entities/role.entity';
import { RoleEnum } from 'src/roles/roles.enum';
import { Repository } from 'typeorm';
@Injectable()
export class RoleSeedService {
constructor(
@InjectRepository(Role)
private repository: Repository<Role>,
) {}
async run() {
const countPlayer = await this.repository.count({
where: {
id: RoleEnum.user,
},
});
if (countPlayer === 0) {
await this.repository.save(
this.repository.create({
id: RoleEnum.user,
name: 'user',
}),
);
}
const countAdmins = await this.repository.count({
where: {
id: RoleEnum.admin,
},
});
if (countAdmins === 0) {
await this.repository.save(
this.repository.create({
id: RoleEnum.admin,
name: 'admin',
}),
);
}
}
}

33
myteamwallet_backend/src/database/seeds/run-seed.ts Normal file
View File

@@ -0,0 +1,33 @@
import { NestFactory } from '@nestjs/core';
import { PlayersSeedService } from './player/player-seed.service';
import { RoleSeedService } from './role/role-seed.service';
import { SeedModule } from './seed.module';
import { StatusSeedService } from './status/status-seed.service';
import { TeamRoleSeedService } from './team-role/team-role-seed.service';
import { TeamsSettingsSeedService } from './team-settings/team-settings-seed.service';
import { TeamWalletTransactionTypeSeedService } from './team-wallet-transactions-type/team-wallet-transaction-type-seed.service';
import { TeamWalletTransactionSeedService } from './team-wallet-transactions/team-wallet-transaction-seed.service';
import { TeamsSeedService } from './teams/teams-seed.service';
import { TransactionsTypeSeedService } from './transaction-type/transactions-type-seed.service';
import { TransactionsSeedService } from './transactions/transactions-seed.service';
import { UserSeedService } from './user/user-seed.service';
const runSeed = async () => {
const app = await NestFactory.create(SeedModule);
// run
await app.get(RoleSeedService).run();
await app.get(StatusSeedService).run();
await app.get(UserSeedService).run();
await app.get(TeamRoleSeedService).run();
await app.get(TeamsSeedService).run();
await app.get(PlayersSeedService).run();
await app.get(TransactionsTypeSeedService).run();
await app.get(TransactionsSeedService).run();
await app.get(TeamsSettingsSeedService).run();
await app.get(TeamWalletTransactionTypeSeedService).run();
await app.get(TeamWalletTransactionSeedService).run();
await app.close();
};
void runSeed();

47
myteamwallet_backend/src/database/seeds/seed.module.ts Normal file
View File

@@ -0,0 +1,47 @@
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import appConfig from 'src/config/app.config';
import databaseConfig from 'src/config/database.config';
import { DataSource } from 'typeorm';
import { TypeOrmConfigService } from '../typeorm-config.service';
import { PlayersSeedModule } from './player/player-seed.module';
import { RoleSeedModule } from './role/role-seed.module';
import { StatusSeedModule } from './status/status-seed.module';
import { TeamRolesSeedModule } from './team-role/team-role-seed.module';
import { TeamSettingsSeedModule } from './team-settings/team-settings-seed.module';
import { TeamWalletTransactionTypeSeedModule } from './team-wallet-transactions-type/team-wallet-transaction-type-seed.module';
import { TeamWalletTransactionSeedModule } from './team-wallet-transactions/team-wallet-transaction-seed.module';
import { TeamsSeedModule } from './teams/teams-seed.module';
import { TransactionsTypeSeedModule } from './transaction-type/transactions-type-seed.module';
import { TransactionsSeedModule } from './transactions/transactions-seed.module';
import { UserSeedModule } from './user/user-seed.module';
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
load: [databaseConfig, appConfig],
envFilePath: ['.env'],
}),
TypeOrmModule.forRootAsync({
useClass: TypeOrmConfigService,
dataSourceFactory: async (options) => {
const dataSource = await new DataSource(options).initialize();
return dataSource;
},
}),
RoleSeedModule,
StatusSeedModule,
UserSeedModule,
TeamRolesSeedModule,
TeamsSeedModule,
PlayersSeedModule,
TransactionsTypeSeedModule,
TransactionsSeedModule,
TeamSettingsSeedModule,
TeamWalletTransactionTypeSeedModule,
TeamWalletTransactionSeedModule,
],
})
export class SeedModule {}

11
myteamwallet_backend/src/database/seeds/status/status-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Status } from 'src/statuses/entities/status.entity';
import { StatusSeedService } from './status-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([Status])],
providers: [StatusSeedService],
exports: [StatusSeedService],
})
export class StatusSeedModule {}

30
myteamwallet_backend/src/database/seeds/status/status-seed.service.ts Normal file
View File

@@ -0,0 +1,30 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Status } from 'src/statuses/entities/status.entity';
import { StatusEnum } from 'src/statuses/statuses.enum';
import { Repository } from 'typeorm';
@Injectable()
export class StatusSeedService {
constructor(
@InjectRepository(Status)
private repository: Repository<Status>,
) {}
async run() {
const count = await this.repository.count();
if (count === 0) {
await this.repository.save([
this.repository.create({
id: StatusEnum.active,
name: 'Active',
}),
this.repository.create({
id: StatusEnum.inactive,
name: 'Inactive',
}),
]);
}
}
}

11
myteamwallet_backend/src/database/seeds/team-role/team-role-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TeamRole } from 'src/team-roles/entities/team-roles.entity';
import { TeamRoleSeedService } from './team-role-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([TeamRole])],
providers: [TeamRoleSeedService],
exports: [TeamRoleSeedService],
})
export class TeamRolesSeedModule {}

90
myteamwallet_backend/src/database/seeds/team-role/team-role-seed.service.ts Normal file
View File

@@ -0,0 +1,90 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TeamRole } from 'src/team-roles/entities/team-roles.entity';
import { TeamRolesEnum } from 'src/team-roles/team-roles.enum';
import { Repository } from 'typeorm';
@Injectable()
export class TeamRoleSeedService {
constructor(
@InjectRepository(TeamRole)
private repository: Repository<TeamRole>,
) {}
async run() {
const countPlayer = await this.repository.count({
where: {
id: TeamRolesEnum.player,
},
});
if (countPlayer === 0) {
await this.repository.save(
this.repository.create({
id: TeamRolesEnum.player,
name: 'player',
}),
);
}
const countScndTr = await this.repository.count({
where: {
id: TeamRolesEnum.scnd_treasurer,
},
});
if (countScndTr === 0) {
await this.repository.save(
this.repository.create({
id: TeamRolesEnum.scnd_treasurer,
name: 'scnd_treasurer',
}),
);
}
const countCaptain = await this.repository.count({
where: {
id: TeamRolesEnum.captain,
},
});
if (countCaptain === 0) {
await this.repository.save(
this.repository.create({
id: TeamRolesEnum.captain,
name: 'captain',
}),
);
}
const countTreasurer = await this.repository.count({
where: {
id: TeamRolesEnum.treasurer,
},
});
if (countTreasurer === 0) {
await this.repository.save(
this.repository.create({
id: TeamRolesEnum.treasurer,
name: 'treasurer',
}),
);
}
const countCoach = await this.repository.count({
where: {
id: TeamRolesEnum.coach,
},
});
if (countCoach === 0) {
await this.repository.save(
this.repository.create({
id: TeamRolesEnum.coach,
name: 'coach',
}),
);
}
}
}

12
myteamwallet_backend/src/database/seeds/team-settings/team-settings-seed.module.ts Normal file
View File

@@ -0,0 +1,12 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TeamSetting } from 'src/team-settings/entities/team-setting.entity';
import { Team } from 'src/teams/entities/team.entity';
import { TeamsSettingsSeedService } from './team-settings-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([Team, TeamSetting])],
providers: [TeamsSettingsSeedService],
exports: [TeamsSettingsSeedService],
})
export class TeamSettingsSeedModule {}

30
myteamwallet_backend/src/database/seeds/team-settings/team-settings-seed.service.ts Normal file
View File

@@ -0,0 +1,30 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TeamSetting } from 'src/team-settings/entities/team-setting.entity';
import { Team } from 'src/teams/entities/team.entity';
import { Repository } from 'typeorm';
@Injectable()
export class TeamsSettingsSeedService {
constructor(
@InjectRepository(TeamSetting)
private repository: Repository<TeamSetting>,
@InjectRepository(Team)
private teamrepository: Repository<Team>,
) {}
async run() {
const countTeamSettings = await this.repository.count();
if (countTeamSettings === 0) {
const team = await this.teamrepository.findOne({ where: { id: 1 } });
await this.repository.save(
this.repository.create({
team,
key: 'transaction_create_min_role',
value: '2',
}),
);
}
}
}

11
myteamwallet_backend/src/database/seeds/team-wallet-transactions-type/team-wallet-transaction-type-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TeamWalletTransactionType } from 'src/team-wallet-transactions/entities/team-wallet-transaction-type.entity';
import { TeamWalletTransactionTypeSeedService } from './team-wallet-transaction-type-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([TeamWalletTransactionType])],
providers: [TeamWalletTransactionTypeSeedService],
exports: [TeamWalletTransactionTypeSeedService],
})
export class TeamWalletTransactionTypeSeedModule {}

37
myteamwallet_backend/src/database/seeds/team-wallet-transactions-type/team-wallet-transaction-type-seed.service.ts Normal file
View File

@@ -0,0 +1,37 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TeamWalletTransactionType } from 'src/team-wallet-transactions/entities/team-wallet-transaction-type.entity';
import { TeamWalletTransactionEnum } from 'src/team-wallet-transactions/team-wallet-transaction.enum';
import { Repository } from 'typeorm';
@Injectable()
export class TeamWalletTransactionTypeSeedService {
constructor(
@InjectRepository(TeamWalletTransactionType)
private repository: Repository<TeamWalletTransactionType>,
) {}
async run() {
const amount = await this.repository.count({
where: {
id: 0,
},
});
if (amount === 0) {
await this.repository.save(
this.repository.create({
id: TeamWalletTransactionEnum.credit,
name: 'credit',
}),
);
await this.repository.save(
this.repository.create({
id: TeamWalletTransactionEnum.expense,
name: 'expense',
}),
);
}
}
}

12
myteamwallet_backend/src/database/seeds/team-wallet-transactions/team-wallet-transaction-seed.module.ts Normal file
View File

@@ -0,0 +1,12 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TeamWalletTransaction } from 'src/team-wallet-transactions/entities/team-wallet-transaction.entity';
import { Team } from 'src/teams/entities/team.entity';
import { TeamWalletTransactionSeedService } from './team-wallet-transaction-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([TeamWalletTransaction, Team])],
providers: [TeamWalletTransactionSeedService],
exports: [TeamWalletTransactionSeedService],
})
export class TeamWalletTransactionSeedModule {}

44
myteamwallet_backend/src/database/seeds/team-wallet-transactions/team-wallet-transaction-seed.service.ts Normal file
View File

@@ -0,0 +1,44 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TeamWalletTransaction } from 'src/team-wallet-transactions/entities/team-wallet-transaction.entity';
import { TeamWalletTransactionEnum } from 'src/team-wallet-transactions/team-wallet-transaction.enum';
import { Team } from 'src/teams/entities/team.entity';
import { Repository } from 'typeorm';
import { faker } from '@faker-js/faker';
@Injectable()
export class TeamWalletTransactionSeedService {
constructor(
@InjectRepository(TeamWalletTransaction)
private repository: Repository<TeamWalletTransaction>,
@InjectRepository(Team)
private teamrepository: Repository<Team>,
) {}
async run() {
const amount = await this.repository.count({
where: {
id: 0,
},
});
if (amount === 0) {
const team = await this.teamrepository.findOneBy({ id: 1 });
for (let index = 0; index < 20; index++) {
await this.repository.save(
this.repository.create({
team: team,
note: '',
date: faker.date.recent(90).toISOString(),
amount: Math.random() * 10,
type: {
id: TeamWalletTransactionEnum.credit,
name: 'credit',
},
}),
);
}
}
}
}

11
myteamwallet_backend/src/database/seeds/teams/teams-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Team } from 'src/teams/entities/team.entity';
import { TeamsSeedService } from './teams-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([Team])],
providers: [TeamsSeedService],
exports: [TeamsSeedService],
})
export class TeamsSeedModule {}

30
myteamwallet_backend/src/database/seeds/teams/teams-seed.service.ts Normal file
View File

@@ -0,0 +1,30 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Team } from 'src/teams/entities/team.entity';
import { Repository } from 'typeorm';
@Injectable()
export class TeamsSeedService {
constructor(
@InjectRepository(Team)
private repository: Repository<Team>,
) {}
async run() {
const countTeams = await this.repository.count({
where: {
id: 1,
},
});
if (countTeams === 0) {
await this.repository.save(
this.repository.create({
id: 1,
name: 'Development Team',
alias: '9999',
}),
);
}
}
}

11
myteamwallet_backend/src/database/seeds/transaction-type/transactions-type-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TransactionType } from 'src/transactions/entitites/transaction-type.entity';
import { TransactionsTypeSeedService } from './transactions-type-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([TransactionType])],
providers: [TransactionsTypeSeedService],
exports: [TransactionsTypeSeedService],
})
export class TransactionsTypeSeedModule {}

42
myteamwallet_backend/src/database/seeds/transaction-type/transactions-type-seed.service.ts Normal file
View File

@@ -0,0 +1,42 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TransactionType } from 'src/transactions/entitites/transaction-type.entity';
import { TransactionTypeEnum } from 'src/transactions/transaction-type.enum';
import { Repository } from 'typeorm';
@Injectable()
export class TransactionsTypeSeedService {
constructor(
@InjectRepository(TransactionType)
private repository: Repository<TransactionType>,
) {}
async run() {
const count = await this.repository.count();
if (count === 0) {
await this.repository.save([
this.repository.create({
id: TransactionTypeEnum.credit,
name: 'credit',
}),
this.repository.create({
id: TransactionTypeEnum.fee,
name: 'fee',
}),
this.repository.create({
id: TransactionTypeEnum.fine,
name: 'fine',
}),
this.repository.create({
id: TransactionTypeEnum.levy,
name: 'levy',
}),
this.repository.create({
id: TransactionTypeEnum.payment,
name: 'payment',
}),
]);
}
}
}

13
myteamwallet_backend/src/database/seeds/transactions/transactions-seed.module.ts Normal file
View File

@@ -0,0 +1,13 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Player } from 'src/players/entities/player.entity';
import { TransactionType } from 'src/transactions/entitites/transaction-type.entity';
import { Transaction } from 'src/transactions/entitites/transaction.entity';
import { TransactionsSeedService } from './transactions-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([TransactionType, Transaction, Player])],
providers: [TransactionsSeedService],
exports: [TransactionsSeedService],
})
export class TransactionsSeedModule {}

45
myteamwallet_backend/src/database/seeds/transactions/transactions-seed.service.ts Normal file
View File

@@ -0,0 +1,45 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Player } from 'src/players/entities/player.entity';
import { TransactionType } from 'src/transactions/entitites/transaction-type.entity';
import { Transaction } from 'src/transactions/entitites/transaction.entity';
import { Repository } from 'typeorm';
import { faker } from '@faker-js/faker';
@Injectable()
export class TransactionsSeedService {
constructor(
@InjectRepository(Transaction)
private repository: Repository<Transaction>,
@InjectRepository(Player)
private playerRepository: Repository<Player>,
@InjectRepository(TransactionType)
private transactionTypeRepository: Repository<TransactionType>,
) {}
async run() {
const count = await this.repository.count();
if (count === 0) {
const players = await this.playerRepository.find();
const transactionTypes = await this.transactionTypeRepository.find();
const transactions = [];
for (let x = 0; x < 500; x++) {
const p = Math.floor(Math.random() * players.length);
const type = Math.floor(Math.random() * transactionTypes.length);
const t = this.repository.create({
amount: Math.random() * 50,
player: players[p],
type: transactionTypes[type],
note: faker.hacker.phrase(),
date: faker.date.recent(90).toISOString(),
});
transactions.push(t);
}
await this.repository.save(transactions);
}
}
}

11
myteamwallet_backend/src/database/seeds/user/user-seed.module.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from 'src/users/entities/user.entity';
import { UserSeedService } from './user-seed.service';
@Module({
imports: [TypeOrmModule.forFeature([User])],
providers: [UserSeedService],
exports: [UserSeedService],
})
export class UserSeedModule {}

70
myteamwallet_backend/src/database/seeds/user/user-seed.service.ts Normal file
View File

@@ -0,0 +1,70 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { RoleEnum } from 'src/roles/roles.enum';
import { StatusEnum } from 'src/statuses/statuses.enum';
import { User } from 'src/users/entities/user.entity';
import { Repository } from 'typeorm';
@Injectable()
export class UserSeedService {
constructor(
@InjectRepository(User)
private repository: Repository<User>,
) {}
async run() {
const countAdmin = await this.repository.count({
where: {
role: {
id: RoleEnum.admin,
},
},
});
if (countAdmin === 0) {
await this.repository.save(
this.repository.create({
firstName: 'Bastian',
lastName: 'Wagner',
email: 'mail@bastian-wagner.de',
password: 'Passwort123',
role: {
id: RoleEnum.admin,
name: 'Admin',
},
status: {
id: StatusEnum.active,
name: 'Active',
},
}),
);
}
const countUser = await this.repository.count({
where: {
role: {
id: RoleEnum.user,
},
},
});
if (countUser === 0) {
await this.repository.save(
this.repository.create({
firstName: 'John',
lastName: 'Doe',
email: 'john.doe@example.com',
password: 'secret',
role: {
id: RoleEnum.user,
name: 'Admin',
},
status: {
id: StatusEnum.active,
name: 'Active',
},
}),
);
}
}
}

31
myteamwallet_backend/src/database/typeorm-config.service.ts Normal file
View File

@@ -0,0 +1,31 @@
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
@Injectable()
export class TypeOrmConfigService implements TypeOrmOptionsFactory {
constructor(private configService: ConfigService) {}
createTypeOrmOptions(): TypeOrmModuleOptions {
return {
type: this.configService.get('database.type'),
url: this.configService.get('database.url'),
host: this.configService.get('database.host'),
port: this.configService.get('database.port'),
username: this.configService.get('database.username'),
password: this.configService.get('database.password'),
database: this.configService.get('database.name'),
synchronize: this.configService.get('database.synchronize'),
dropSchema: false,
keepConnectionAlive: true,
logging: this.configService.get('app.nodeEnv') !== 'prod',
entities: [__dirname + '/../**/*.entity{.ts,.js}'],
migrations: [__dirname + '/migrations/**/*{.ts,.js}'],
cli: {
entitiesDir: 'src',
migrationsDir: 'src/database/migrations',
subscribersDir: 'subscriber',
},
} as TypeOrmModuleOptions;
}
}