@natrave/shared-entities 1.1.1

package/src/tournaments/tournament-match-goals/tournament-match-goal.entity.ts

@@ -0,0 +1,88 @@
+import { ITournamentMatchGoal, MatchPeriod } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Index,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+
+import { TournamentMatch } from 'tournaments/tournament-matches';
+import { TournamentPlayer } from 'tournaments/tournament-players';
+import { TournamentTeam } from 'tournaments/tournament-teams';
+
+/**
+ * Entidade que representa um gol marcado em uma partida do campeonato.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de um gol, incluindo o identificador do time que marcou,
+ * o identificador da partida, o minuto (opcional), o período da partida (opcional),
+ * os identificadores do jogador que marcou e do jogador que fez a assistência (opcionais),
+ * além das datas de criação e atualização do registro.
+ *
+ * @public
+ */
+@Entity('tournament_match_goals')
+@Index(['teamId'])
+@Index(['matchId'])
+export class TournamentMatchGoal implements ITournamentMatchGoal {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'team_id', type: 'int' })
+  teamId: number;
+
+  @Column({ name: 'match_id', type: 'int' })
+  matchId: number;
+
+  @Column({ type: 'int', nullable: true })
+  minute?: number;
+
+  @Column({ type: 'enum', enum: MatchPeriod, nullable: true })
+  period?: MatchPeriod;
+
+  @Column({ name: 'scorer_id', type: 'int', nullable: true })
+  scorerId?: number;
+
+  @Column({ name: 'assist_id', type: 'int', nullable: true })
+  assistId?: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o time associado ao gol.
+   */
+  @ManyToOne(() => TournamentTeam, (team) => team.goals, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'team_id' })
+  team?: TournamentTeam;
+
+  /**
+   * Relação com a partida associada ao gol.
+   */
+  @ManyToOne(() => TournamentMatch, (match) => match.goals, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'team_id' })
+  match?: TournamentMatch;
+
+  /**
+   * Relação com o jogador autor do gol associado ao evento de gol.
+   */
+  @ManyToOne(() => TournamentPlayer, (team) => team.goals, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'scorer_id' })
+  scorer?: TournamentPlayer;
+
+  /**
+   * Relação com o jogador autor da assistencia associado ao evento de gol.
+   */
+  @ManyToOne(() => TournamentPlayer, (team) => team.assists, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'assist_id' })
+  assist?: TournamentPlayer;
+}

package/src/tournaments/tournament-match-schemas/index.ts

@@ -0,0 +1 @@
+export { TournamentMatchSchema } from './tournament-match-schema.entity';

package/src/tournaments/tournament-match-schemas/tournament-match-schema.entity.ts

@@ -0,0 +1,51 @@
+import { ITournamentMatchSchema } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Index,
+  OneToMany,
+} from 'typeorm';
+
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa um esquema de partidas de torneio.
+ *
+ * @remarks
+ * Esta entidade armazena os dados referentes a um esquema de partidas, como o nome, descrição
+ * e quantidade de jogadores por equipe, além das datas de criação e atualização do registro.
+ *
+ * @public
+ */
+@Entity('tournament_match_schemas')
+@Index(['name'])
+export class TournamentMatchSchema implements ITournamentMatchSchema {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'varchar', length: 100 })
+  name: string;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  description?: string;
+
+  @Column({ type: 'int', name: 'players_per_team' })
+  playersPerTeam: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os campeonatos associadas ao esquema de partidas.
+   */
+  @OneToMany(() => Tournament, (tournament) => tournament.matchSchema)
+  tournaments: Tournament[];
+}

package/src/tournaments/tournament-matches/index.ts

@@ -0,0 +1 @@
+export { TournamentMatch } from './tournament-match.entity';

package/src/tournaments/tournament-matches/tournament-match.entity.ts

@@ -0,0 +1,101 @@
+import { ITournamentMatch } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm';
+
+import { Field } from 'facilities';
+import { TournamentMatchCard } from 'tournaments/tournament-match-cards';
+import { TournamentMatchGoal } from 'tournaments/tournament-match-goals';
+import { TournamentTeam } from 'tournaments/tournament-teams';
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa uma partida de torneio.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de uma partida de torneio, incluindo os identificadores dos times (casa e visitante),
+ * o identificador do campo (opcional), a data do jogo e as datas de criação e atualização do registro.
+ *
+ * @public
+ */
+@Entity('tournament_matches')
+export class TournamentMatch implements ITournamentMatch {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'tournament_id', type: 'int' })
+  tournamentId: number;
+
+  @Column({ name: 'home_team_id', type: 'int' })
+  homeTeamId: number;
+
+  @Column({ name: 'away_team_id', type: 'int' })
+  awayTeamId: number;
+
+  @Column({ name: 'field_id', type: 'int', nullable: true })
+  fieldId?: number;
+
+  @Column({ name: 'match_date', type: 'timestamptz' })
+  matchDate: Date;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o campo ao qual a partida esta associada.
+   */
+  @ManyToOne(() => Field, (field) => field.tournamentMatches, { onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'field_id' })
+  field?: Field;
+
+  /**
+   * Relação com o campeonato ao qual a partida esta associada.
+   */
+  @ManyToOne(() => Tournament, (tournament) => tournament.matches, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+
+  /**
+   * Relação com o time da casa ao qual a partida esta associada.
+   */
+  @ManyToOne(() => TournamentTeam, (team) => team.homeMatches, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'home_team_id' })
+  homeTeam: TournamentTeam;
+
+  /**
+   * Relação com o time visitante ao qual a partida esta associada.
+   */
+  @ManyToOne(() => TournamentTeam, (team) => team.awayMatches, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'away_team_id' })
+  awayTeam: TournamentTeam;
+
+  /**
+   * Relação com os gols associados a partida.
+   */
+  @OneToMany(() => TournamentMatchGoal, (goal) => goal.match)
+  goals: TournamentMatchGoal[];
+
+  /**
+   * Relação com os cartões associados a partida.
+   */
+  @OneToMany(() => TournamentMatchCard, (card) => card.match)
+  cards: TournamentMatchCard[];
+}

package/src/tournaments/tournament-payments/index.ts

@@ -0,0 +1 @@
+export { TournamentPayment } from './tournament-payment.entity';

package/src/tournaments/tournament-payments/tournament-payment.entity.ts

@@ -0,0 +1,67 @@
+import { ITournamentPayment } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+
+import { User } from 'app-auth';
+import { Payment } from 'payments';
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa um pagamento realizado para um torneio.
+ *
+ * @remarks
+ * Esta entidade armazena os dados do pagamento associado a um torneio,
+ * vinculando o pagamento a um usuário e ao torneio correspondente.
+ *
+ * @public
+ */
+@Entity('tournament_payments')
+export class TournamentPayment implements ITournamentPayment {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ name: 'payment_id', type: 'int' })
+  paymentId: number;
+
+  @Column({ name: 'tournament_id', type: 'int' })
+  tournamentId: number;
+
+  @Column({ name: 'user_id', type: 'uuid' })
+  userId: string;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o usuário ao qual o pagamento esta associado.
+   */
+  @ManyToOne(() => User, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  /**
+   * Relação com o pagamento ao qual o pagamento do torneio esta associado.
+   */
+  @ManyToOne(() => Payment, { onDelete: 'CASCADE', eager: true })
+  @JoinColumn({ name: 'payment_id' })
+  payment: Payment;
+
+  /**
+   * Relação com o torneio ao qual o pagamento do torneio esta associado.
+   */
+  @ManyToOne(() => Tournament, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+}

package/src/tournaments/tournament-players/index.ts

@@ -0,0 +1 @@
+export { TournamentPlayer } from './tournament-player.entity';

package/src/tournaments/tournament-players/tournament-player.entity.ts

@@ -0,0 +1,96 @@
+import { ITournamentPlayer } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  Index,
+  OneToMany,
+} from 'typeorm';
+
+import { User } from 'app-auth';
+import { TournamentMatchCard } from 'tournaments/tournament-match-cards';
+import { TournamentMatchGoal } from 'tournaments/tournament-match-goals';
+import { TournamentTeam } from 'tournaments/tournament-teams';
+
+/**
+ * Entidade que representa um jogador de torneio.
+ *
+ * @remarks
+ * Esta entidade associa um usuário a um time em um torneio e indica se o usuário é o dono do time.
+ *
+ * São utilizados:
+ * - Uma restrição única para garantir que um usuário não seja associado a mais de um time no mesmo torneio.
+ * - Índices em "userId" e "teamId" para otimizar consultas.
+ *
+ * @public
+ */
+@Entity('tournament_players')
+@Unique(['userId', 'teamId'])
+@Index('IDX_user_id', ['userId'])
+@Index('IDX_team_id', ['teamId'])
+export class TournamentPlayer implements ITournamentPlayer {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id', type: 'uuid' })
+  userId: string;
+
+  @Column({ name: 'team_id', type: 'int' })
+  teamId: number;
+
+  @Column({ name: 'is_owner', type: 'boolean', default: false })
+  isOwner: boolean;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o time ao qual o jogador esta associado.
+   */
+
+  @ManyToOne(() => TournamentTeam, (team) => team.players, {
+    onDelete: 'CASCADE',
+    eager: true,
+  })
+  @JoinColumn({ name: 'team_id' })
+  team: TournamentTeam;
+
+  /**
+   * Relação com o usuário ao qual os jogador esta associado.
+   */
+
+  @ManyToOne(() => User, (user) => user.tournamentPlayers, {
+    onDelete: 'CASCADE',
+    eager: true,
+  })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  /**
+   * Relação com os gols associados ao jogador.
+   */
+  @OneToMany(() => TournamentMatchGoal, (goal) => goal.scorer)
+  goals: TournamentMatchGoal[];
+
+  /**
+   * Relação com as assistências associados ao jogador.
+   */
+  @OneToMany(() => TournamentMatchGoal, (goal) => goal.assist)
+  assists: TournamentMatchGoal[];
+
+  /**
+   * Relação com os cartões associados ao jogador.
+   */
+  @OneToMany(() => TournamentMatchCard, (card) => card.player)
+  cards: TournamentMatchCard[];
+}

package/src/tournaments/tournament-prize-rules/index.ts

@@ -0,0 +1 @@
+export { TournamentPrizeRule } from './tournament-prize-rule.entity';

package/src/tournaments/tournament-prize-rules/tournament-prize-rule.entity.ts

@@ -0,0 +1,65 @@
+import { ITournamentPrizeRule } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Index,
+  Check,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa as regras de premiação para torneios.
+ *
+ * @remarks
+ * Esta entidade armazena o valor do prêmio, a classificação associada e, opcionalmente, uma descrição,
+ * garantindo que o valor do prêmio e a classificação sejam não-negativos.
+ *
+ * São utilizados:
+ * - Um índice composto em [tournamentId, rank] para otimizar consultas por torneio e posição.
+ * - Check constraints para assegurar que "amount" e "rank" sejam maiores ou iguais a zero.
+ *
+ * @public
+ */
+@Entity('tournament_prize_rules')
+@Index(['tournamentId', 'rank'])
+@Check('CHK_TOURNAMENT_PRIZE_RULES_NON_NEGATIVE', 'amount >= 0 AND rank >= 0')
+export class TournamentPrizeRule implements ITournamentPrizeRule {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'tournament_id', type: 'int' })
+  tournamentId: number;
+
+  @Column({ type: 'int' })
+  amount: number;
+
+  @Column({ type: 'int' })
+  rank: number;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  description?: string;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o torneio ao qual as regras estão associadas.
+   */
+
+  @ManyToOne(() => Tournament, (tournament) => tournament.prizeRules, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+}

package/src/tournaments/tournament-rules/index.ts

@@ -0,0 +1 @@
+export { TournamentRule } from './tournament-rule.entity';

package/src/tournaments/tournament-rules/tournament-rule.entity.ts

@@ -0,0 +1,81 @@
+import { ITournamentRule } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  JoinColumn,
+  Check,
+  OneToOne,
+} from 'typeorm';
+
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa as regras de um torneio.
+ *
+ * @remarks
+ * Esta entidade armazena os limites de jogadores por time, faixas etárias, número mínimo e máximo de times,
+ * além de informações adicionais, como observações e URL do regulamento em PDF.
+ *
+ * @public
+ */
+@Entity('tournament_rules')
+@Check('CHK_TEAMS', '"max_teams" >= "min_teams"')
+@Check('CHK_PLAYERS_PER_TEAM', '"max_player_per_team" >= "min_player_per_team"')
+@Check('CHK_MIN_AGE', '"min_age" >= 0')
+@Check('CHK_MAX_AGE', '"max_age" IS NULL OR "max_age" > "min_age"')
+export class TournamentRule implements ITournamentRule {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'tournament_id', type: 'int', unique: true })
+  tournamentId: number;
+
+  @Column({ name: 'max_player_per_team', type: 'int' })
+  maxPlayerPerTeam: number;
+
+  @Column({ name: 'min_player_per_team', type: 'int' })
+  minPlayerPerTeam: number;
+
+  @Column({ name: 'min_age', type: 'int' })
+  minAge: number;
+
+  @Column({ name: 'max_age', type: 'int', nullable: true })
+  maxAge?: number;
+
+  @Column({ name: 'min_teams', type: 'int' })
+  minTeams: number;
+
+  @Column({ name: 'max_teams', type: 'int' })
+  maxTeams: number;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  notes?: string;
+
+  @Column({
+    name: 'regulation_pdf_url',
+    type: 'varchar',
+    length: 500,
+    nullable: true,
+  })
+  regulationPdfUrl?: string;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o torneio ao qual as regras estão associadas.
+   */
+  @OneToOne(() => Tournament, (tournament) => tournament.rule, {
+    cascade: true,
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+}

package/src/tournaments/tournament-teams/index.ts

@@ -0,0 +1 @@
+export { TournamentTeam } from './tournament-team.entity';

package/src/tournaments/tournament-teams/tournament-team.entity.ts

@@ -0,0 +1,111 @@
+import { ITournamentTeam } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  Index,
+  BeforeInsert,
+  OneToMany,
+} from 'typeorm';
+
+import { TournamentMatchCard } from 'tournaments/tournament-match-cards';
+import { TournamentMatchGoal } from 'tournaments/tournament-match-goals';
+import { TournamentMatch } from 'tournaments/tournament-matches';
+import { TournamentPlayer } from 'tournaments/tournament-players';
+import { Tournament } from 'tournaments/tournaments';
+
+import { generateRandomInviteCode } from './utils/invite-code-generator';
+
+/**
+ * Entidade que representa um time de torneio.
+ *
+ * @remarks
+ * Esta entidade armazena informações básicas sobre o time de um torneio, como o nome, logo, descrição e código de convite único.
+ * Além disso, mantém a referência ao torneio ao qual o time está associado e registra as datas de criação e atualização.
+ *
+ * @public
+ */
+@Entity('tournament_teams')
+@Unique(['tournamentId', 'name'])
+@Unique(['inviteCode'])
+@Index('IDX_tournament_team_tournament_id', ['tournamentId'])
+@Index('IDX_tournament_team_invite_code', ['inviteCode'])
+export class TournamentTeam implements ITournamentTeam {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'tournament_id', type: 'int' })
+  tournamentId: number;
+
+  @Column({ type: 'varchar', length: 100 })
+  name: string;
+
+  @Column({ name: 'team_logo_url', type: 'text', nullable: true })
+  teamLogoUrl?: string;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  description?: string;
+
+  @Column({ name: 'invite_code', type: 'varchar', length: 5, unique: true })
+  inviteCode: string;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o torneio ao qual o time está associado.
+   */
+  @ManyToOne(() => Tournament, (tournament) => tournament.teams, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+
+  /**
+   * Relação com os jogadores associados ao time.
+   */
+  @OneToMany(() => TournamentPlayer, (player) => player.team)
+  players: TournamentPlayer[];
+
+  /**
+   * Relação com as partidas em casa associadas ao time.
+   */
+  @OneToMany(() => TournamentMatch, (match) => match.homeTeam)
+  homeMatches: TournamentMatch[];
+
+  /**
+   * Relação com as partidas fora de casa associadas ao time.
+   */
+  @OneToMany(() => TournamentMatch, (match) => match.awayTeam)
+  awayMatches: TournamentMatch[];
+
+  /**
+   * Relação com os gols associados ao time.
+   */
+  @OneToMany(() => TournamentMatchGoal, (goal) => goal.team)
+  goals: TournamentMatchGoal[];
+
+  /**
+   * Relação com os cartões associados ao time.
+   */
+  @OneToMany(() => TournamentMatchCard, (card) => card.team)
+  cards: TournamentMatchCard[];
+
+  /**
+   * Gera o código de convite antes de inserir o registro.
+   */
+  @BeforeInsert()
+  generateInviteCode(): void {
+    this.inviteCode = generateRandomInviteCode();
+  }
+}