@natrave/shared-entities 1.1.1

package/src/facilities/fields/field.entity.ts

@@ -0,0 +1,74 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  OneToMany,
+} from 'typeorm';
+
+import { Facility } from 'facilities/facilities';
+import { TournamentMatch } from 'tournaments';
+
+import { FieldSurfaceType } from './enums/surface-type.enum';
+
+/**
+ * Entidade que representa um campo.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de um campo associado a um estabelecimento, incluindo seu nome, tipo de superfície,
+ * dimensões, se é coberto e o número recomendado de jogadores por time. Além disso, mantém as relações com
+ * disponibilidades, imagens, sessões de jogo e partidas de torneio associadas.
+ *
+ * @public
+ */
+@Entity('fields')
+@Unique(['name', 'facilityId'])
+export class Field {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'facility_id', type: 'int' })
+  facilityId: number;
+
+  @ManyToOne(() => Facility, (facility) => facility.fields, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'facility_id' })
+  facility: Facility;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @Column({ type: 'varchar', length: 255 })
+  name: string;
+
+  @Column({ name: 'surface_type', type: 'enum', enum: FieldSurfaceType })
+  surfaceType: FieldSurfaceType;
+
+  @Column({ type: 'decimal', precision: 5, scale: 2 })
+  length: number;
+
+  @Column({ type: 'decimal', precision: 5, scale: 2 })
+  width: number;
+
+  @Column({ name: 'is_indoor', type: 'boolean', default: false })
+  isIndoor: boolean;
+
+  @Column({ name: 'recommended_players_per_team', type: 'int' })
+  recommendedPlayersPerTeam: number;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com as partidas de torneio associadas a este campo.
+   */
+  @OneToMany(() => TournamentMatch, (tournamentMatch) => tournamentMatch.field)
+  tournamentMatches: TournamentMatch[];
+}

package/src/facilities/fields/index.ts

@@ -0,0 +1,3 @@
+export { Field } from './field.entity';
+
+export { FieldSurfaceType } from './enums/surface-type.enum';

package/src/facilities/index.ts

@@ -0,0 +1,5 @@
+export * from './facility-owners';
+export * from './addresses';
+export * from './fields';
+export * from './facility-images';
+export * from './facilities';

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from 'tournaments';
+
+export * from 'app-auth';
+
+export * from 'payments';
+
+export * from 'facilities';

package/src/payments/index.ts

@@ -0,0 +1,5 @@
+export * from './payment-providers';
+
+export * from './user-payment-providers';
+
+export * from './payments';

package/src/payments/payment-providers/enums/payment-provider-name.enum.ts

@@ -0,0 +1,15 @@
+/**
+ * Enum que representa os nomes dos provedores de pagamento.
+ *
+ * @remarks
+ * Este enum fornece valores para identificar o provedor de pagamento utilizado,
+ * garantindo consistência ao referenciar o provedor na aplicação.
+ *
+ * @public
+ */
+export enum PaymentProviderName {
+  /**
+   * Provedor de pagamento Pagar.me.
+   */
+  PAGARME = 'pagarme',
+}

package/src/payments/payment-providers/index.ts

@@ -0,0 +1,3 @@
+export { PaymentProviderName } from './enums/payment-provider-name.enum';
+
+export { PaymentProvider } from './payment-provider.entity';

package/src/payments/payment-providers/payment-provider.entity.ts

@@ -0,0 +1,61 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+  Index,
+  Unique,
+} from 'typeorm';
+
+import { UserPaymentProvider } from 'payments/user-payment-providers';
+
+import { PaymentProviderName } from './enums/payment-provider-name.enum';
+
+/**
+ * Entidade que representa os provedores de pagamento disponíveis no sistema.
+ *
+ * @remarks
+ * Esta entidade armazena os dados do provedor de pagamento, identificando-o pelo nome (baseado no enum PaymentProviderName)
+ * e registrando as datas de criação e atualização. Também mantém a relação com os provedores de pagamento associados aos usuários.
+ *
+ * @public
+ */
+@Entity('payment_providers')
+@Unique(['name'])
+@Index(['name'])
+export class PaymentProvider {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({
+    type: 'enum',
+    enum: PaymentProviderName,
+    unique: true,
+  })
+  name: PaymentProviderName;
+
+  @CreateDateColumn({
+    name: 'created_at',
+    type: 'timestamptz',
+  })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os provedores de pagamento de usuário associados a este provedor.
+   */
+  @OneToMany(
+    () => UserPaymentProvider,
+    (userPaymentProvider) => userPaymentProvider.paymentProvider,
+    {
+      cascade: true,
+    },
+  )
+  userPaymentProviders: UserPaymentProvider[];
+}

package/src/payments/payments/enums/payment-method.enum.ts

@@ -0,0 +1,20 @@
+/**
+ * Enum que representa os métodos de pagamento disponíveis.
+ *
+ * @remarks
+ * Este enum fornece valores para identificar o método de pagamento utilizado,
+ * garantindo consistência ao referenciar o método de pagamento na aplicação.
+ *
+ * @public
+ */
+export enum PaymentMethod {
+  /**
+   * Pagamento via PIX.
+   */
+  PIX = 'pix',
+
+  /**
+   * Pagamento com cartão de crédito.
+   */
+  CREDIT_CARD = 'credit_card',
+}

package/src/payments/payments/enums/payment-status.enum.ts

@@ -0,0 +1,45 @@
+/**
+ * Enum que representa os status de pagamento disponíveis.
+ *
+ * @remarks
+ * Este enum fornece valores para identificar o status de um pagamento,
+ * garantindo consistência ao referenciar o status na aplicação.
+ *
+ * @public
+ */
+export enum PaymentStatus {
+  /**
+   * Pagamento pendente.
+   */
+  PENDING = 'PENDING',
+
+  /**
+   * Pagamento realizado com sucesso.
+   */
+  PAID = 'PAID',
+
+  /**
+   * Pagamento falhou.
+   */
+  FAILED = 'FAILED',
+
+  /**
+   * Pagamento expirado.
+   */
+  EXPIRED = 'EXPIRED',
+
+  /**
+   * Pagamento cancelado.
+   */
+  CANCELED = 'CANCELED',
+
+  /**
+   * Pagamento reembolsado.
+   */
+  REFUNDED = 'REFUNDED',
+
+  /**
+   * Pagamento em processamento.
+   */
+  PROCESSING = 'PROCESSING',
+}

package/src/payments/payments/index.ts

@@ -0,0 +1,5 @@
+export { Payment } from './payment.entity';
+
+export { PaymentMethod } from './enums/payment-method.enum';
+
+export { PaymentStatus } from './enums/payment-status.enum';

package/src/payments/payments/payment.entity.ts

@@ -0,0 +1,84 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+} from 'typeorm';
+
+import { PaymentProviderName } from 'payments/payment-providers';
+import { TournamentPayment } from 'tournaments';
+
+import { PaymentMethod } from './enums/payment-method.enum';
+import { PaymentStatus } from './enums/payment-status.enum';
+
+/**
+ * Entidade que representa um pagamento.
+ *
+ * @remarks
+ * Esta entidade armazena as informações referentes a um pagamento, incluindo o valor, método, status,
+ * provedor de pagamento, QR code (quando aplicável), data de expiração e as datas de criação e atualização.
+ * Além disso, mantém a relação com os pagamentos de torneio associados a este pagamento.
+ *
+ * @public
+ */
+@Entity('payments')
+export class Payment {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'external_id', type: 'varchar', length: 255, nullable: true })
+  externalId?: string;
+
+  @Column({ type: 'int' })
+  amount: number;
+
+  @Column({
+    name: 'payment_method',
+    type: 'enum',
+    enum: PaymentMethod,
+  })
+  paymentMethod: PaymentMethod;
+
+  @Column({
+    type: 'enum',
+    enum: PaymentStatus,
+    enumName: 'PaymentStatus',
+    default: PaymentStatus.PENDING,
+  })
+  status: PaymentStatus;
+
+  @Column({
+    type: 'enum',
+    enum: PaymentProviderName,
+    enumName: 'PaymentProviderName',
+    default: PaymentProviderName.PAGARME,
+  })
+  paymentProviderName: PaymentProviderName;
+
+  @Column({ name: 'qr_code_url', type: 'text', nullable: true })
+  qrCodeUrl?: string;
+
+  @Column({ name: 'qr_code', type: 'text', nullable: true })
+  qrCode?: string;
+
+  @Column({ name: 'expires_at', type: 'timestamptz', nullable: true })
+  expiresAt?: Date;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os pagamentos de torneio associados a este pagamento.
+   */
+  @OneToMany(() => TournamentPayment, (tournamentPayment) => tournamentPayment.payment, {
+    cascade: true,
+  })
+  tournamentPayments: TournamentPayment[];
+}

package/src/payments/user-payment-providers/index.ts

@@ -0,0 +1 @@
+export { UserPaymentProvider } from './user-payment-provider.entity';

package/src/payments/user-payment-providers/user-payment-provider.entity.ts

@@ -0,0 +1,73 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  Index,
+} from 'typeorm';
+
+import { User } from 'app-auth';
+import { PaymentProvider } from 'payments/payment-providers';
+
+/**
+ * Entidade que vincula um usuário a um provedor de pagamento.
+ *
+ * @remarks
+ * Esta entidade relaciona um usuário aos provedores de pagamento disponíveis no sistema.
+ * Ela garante que cada usuário tenha um registro único para cada provedor e armazena o identificador
+ * do usuário conforme retornado pelo provedor (providerCustomerId).
+ *
+ * @public
+ */
+@Entity('user_payment_providers')
+@Unique(['providerCustomerId'])
+@Unique(['userId', 'paymentProviderId'])
+@Index(['userId', 'paymentProviderId'])
+@Index(['providerCustomerId'])
+export class UserPaymentProvider {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'uuid', name: 'user_id' })
+  userId: string;
+
+  @Column({ type: 'int', name: 'payment_provider_id' })
+  paymentProviderId: number;
+
+  /**
+   * Identificador do usuário dentro do provedor de pagamento.
+   * Esse ID é retornado pelo provedor (exemplo: "cus_123456" no Pagar.me).
+   */
+  @Column({ type: 'text', unique: true })
+  providerCustomerId: 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 este provedor de pagamento está vinculado.
+   */
+  @ManyToOne(() => User, (user) => user.userPaymentProviders, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  /**
+   * Relação com o provedor de pagamento associado a este registro.
+   */
+  @ManyToOne(() => PaymentProvider, (provider) => provider.userPaymentProviders, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'payment_provider_id' })
+  paymentProvider: PaymentProvider;
+}

package/src/tournaments/index.ts

@@ -0,0 +1,12 @@
+export * from './tournament-payments';
+export * from './tournament-rules';
+export * from './tournament-teams';
+export * from './tournament-prize-rules';
+export * from './tournament-players';
+export * from './tournament-matches';
+export * from './tournament-match-schemas';
+export * from './tournament-match-cards';
+export * from './tournament-match-goals';
+export * from './tournament-format-configs';
+export * from './tournament-facilities';
+export * from './tournaments';

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

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

package/src/tournaments/tournament-facilities/tournament-facility.entity.ts

@@ -0,0 +1,67 @@
+import { ITournamentFacility } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  Index,
+} from 'typeorm';
+
+import { Facility } from 'facilities/facilities/facility.entity';
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa o relacionamento entre um torneio e um estabelecimento.
+ *
+ * @remarks
+ * Esta entidade armazena a associação entre um torneio e uma ão,
+ * permitindo identificar qual estabelecimento é o principal para o torneio.
+ *
+ * São aplicadas:
+ * - Uma restrição única para evitar associações duplicadas entre o mesmo torneio e estabelecimento.
+ * - Um índice composto em [tournamentId, isPrimary] para otimizar consultas que filtram pelo estabelecimento principal.
+ *
+ * @public
+ */
+@Entity('tournament_facilities')
+@Unique('tournament_facility_unique', ['tournamentId', 'facilityId'])
+@Index('tournament_is_primary_index', ['tournamentId', 'isPrimary'])
+export class TournamentFacility implements ITournamentFacility {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'facility_id', type: 'int' })
+  facilityId: number;
+
+  @Column({ name: 'tournament_id', type: 'int' })
+  tournamentId: number;
+
+  @Column({ name: 'is_primary', type: 'boolean', default: false })
+  isPrimary: boolean;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  @ManyToOne(() => Tournament, (tournament) => tournament.tournamentFacilities, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+
+  @ManyToOne(() => Facility, (facility) => facility.tournamentFacilities, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'facility_id' })
+  facility: Facility;
+}

package/src/tournaments/tournament-format-configs/index.ts

@@ -0,0 +1 @@
+export { TournamentFormatConfig } from './tournament-format-config.entity';

package/src/tournaments/tournament-format-configs/tournament-format-config.entity.ts

@@ -0,0 +1,69 @@
+import {
+  KnockoutPhase,
+  TournamentFormat,
+  type ITournamentFormatConfig,
+} from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToOne,
+  JoinColumn,
+} from 'typeorm';
+
+import { Tournament } from 'tournaments/tournaments';
+
+/**
+ * Entidade que representa a configuração adicional do formato de um torneio.
+ *
+ * @remarks
+ * Esta entidade armazena os parâmetros que detalham o formato do torneio,
+ * permitindo especificar o número de grupos, se os jogos da fase de grupos são disputados em sistema de ida e volta,
+ * a fase inicial do knockout e se os jogos do knockout são disputados em sistema de ida e volta.
+ *
+ * Geralmente, esta entidade está relacionada a um torneio por meio de uma relação 1:1.
+ *
+ * @public
+ */
+@Entity('tournament_format_configs')
+export class TournamentFormatConfig implements ITournamentFormatConfig {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'tournament_id', type: 'int', unique: true })
+  tournamentId: number;
+
+  @Column({ type: 'enum', enum: TournamentFormat })
+  format: TournamentFormat;
+
+  @Column({ type: 'int', nullable: true })
+  numberOfGroups?: number;
+
+  @Column({ name: 'is_group_home_and_away', type: 'boolean', default: false })
+  isGroupHomeAndAway?: boolean;
+
+  @Column({ name: 'knockout_start_phase', type: 'enum', enum: KnockoutPhase, nullable: true })
+  knockoutStartPhase?: KnockoutPhase;
+
+  @Column({ name: 'is_knockout_home_and_away', type: 'boolean', default: false })
+  isKnockoutHomeAndAway?: boolean;
+
+  @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 formato esta associado.
+   */
+  @OneToOne(() => Tournament, (tournament) => tournament.format, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'tournament_id' })
+  tournament: Tournament;
+}

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

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

package/src/tournaments/tournament-match-cards/tournament-match-card.entity.ts

@@ -0,0 +1,86 @@
+import {
+  CardType,
+  MatchPeriod,
+  type ITournamentMatchCard,
+} from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Index,
+} from 'typeorm';
+
+import { TournamentMatch } from 'tournaments/tournament-matches';
+import { TournamentPlayer } from 'tournaments/tournament-players';
+import { TournamentTeam } from 'tournaments/tournament-teams';
+
+/**
+ * Entidade que representa um evento de cartão em uma partida do campeonato.
+ *
+ * @remarks
+ * Esta entidade armazena os dados referentes a um cartão emitido durante uma partida,
+ * incluindo o minuto (opcional), o período da partida (opcional),
+ * os identificadores do jogador e do time que receberam o cartão, o identificador da partida,
+ * o tipo de cartão, além das datas de criação e atualização do registro.
+ *
+ * @public
+ */
+@Entity('tournament_match_cards')
+@Index(['matchId'])
+@Index(['teamId'])
+@Index(['playerId'])
+export class TournamentMatchCard implements ITournamentMatchCard {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'int', nullable: true })
+  minute?: number;
+
+  @Column({ type: 'enum', enum: MatchPeriod, nullable: true })
+  period?: MatchPeriod;
+
+  @Column({ name: 'player_id', type: 'int' })
+  playerId: number;
+
+  @Column({ name: 'team_id', type: 'int' })
+  teamId: number;
+
+  @Column({ name: 'match_id', type: 'int' })
+  matchId: number;
+
+  @Column({ type: 'enum', enum: CardType })
+  cardType: CardType;
+
+  @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 evento de cartão.
+   */
+  @ManyToOne(() => TournamentTeam, (team) => team.cards, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'team_id' })
+  team: TournamentTeam;
+
+  /**
+   * Relação com a partida associada ao evento de cartão.
+   */
+  @ManyToOne(() => TournamentMatch, (match) => match.cards, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'match_id' })
+  match: TournamentMatch;
+
+  /**
+   * Relação com o jogador associado ao evento de cartão.
+   */
+  @ManyToOne(() => TournamentPlayer, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'player_id' })
+  player: TournamentPlayer;
+}

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

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