@natrave/shared-entities 1.1.1

package/src/tournaments/tournament-teams/utils/invite-code-generator.ts

@@ -0,0 +1,12 @@
+/**
+ * Gera um código de convite aleatório com 5 dígitos.
+ *
+ * @returns {string} Um código de convite como string.
+ *
+ * @remarks
+ * A função utiliza o método Math.random para gerar um número aleatório entre 10000 e 99999,
+ * garantindo que o código tenha sempre 5 dígitos.
+ */
+export function generateRandomInviteCode(): string {
+  return Math.floor(10000 + Math.random() * 90000).toString();
+}

package/src/tournaments/tournaments/index.ts

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

package/src/tournaments/tournaments/tournament.entity.ts

@@ -0,0 +1,153 @@
+import { DayOfWeek, ITournament, TournamentGender } from '@natrave/tournaments-service-types';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+  OneToOne,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+
+import { TournamentFacility } from 'tournaments/tournament-facilities';
+import { TournamentFormatConfig } from 'tournaments/tournament-format-configs';
+import { TournamentMatchSchema } from 'tournaments/tournament-match-schemas';
+import { TournamentMatch } from 'tournaments/tournament-matches';
+import { TournamentPayment } from 'tournaments/tournament-payments';
+import { TournamentPrizeRule } from 'tournaments/tournament-prize-rules';
+import { TournamentRule } from 'tournaments/tournament-rules';
+import { TournamentTeam } from 'tournaments/tournament-teams';
+
+/**
+ * Entidade que representa um torneio.
+ *
+ * @remarks
+ * Esta entidade armazena todas as propriedades essenciais de um torneio, como datas, formato, regras,
+ * dias de partida, informações de localização e gênero, além das datas de criação e atualização.
+ *
+ * @public
+ */
+@Entity('tournaments')
+export class Tournament implements ITournament {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'varchar', length: 255 })
+  name: string;
+
+  @Column({ name: 'initial_date', type: 'timestamptz' })
+  initialDate: Date;
+
+  @Column({ name: 'end_date', type: 'timestamptz' })
+  endDate: Date;
+
+  @Column({ type: 'text', nullable: true })
+  description?: string | null;
+
+  @Column({ name: 'tournament_image', type: 'text', nullable: true })
+  tournamentImage?: string | null;
+
+  @Column({ name: 'match_schema_id', type: 'int', nullable: true })
+  matchSchemaId?: number | null;
+
+  @Column({ name: 'rule_id', type: 'int' })
+  ruleId: number;
+
+  @Column({ name: 'format_config_id', type: 'int' })
+  formatConfigId: number;
+
+  @Column({
+    name: 'match_days',
+    type: 'enum',
+    enum: Object.values(DayOfWeek),
+    array: true,
+  })
+  matchDays: DayOfWeek[];
+
+  @Column({ name: 'price_per_team', type: 'int' })
+  pricePerTeam: number;
+
+  @Column({ name: 'match_start_time', type: 'time' })
+  matchStartTime: string;
+
+  @Column({ name: 'match_end_time', type: 'time' })
+  matchEndTime: string;
+
+  @Column({ type: 'varchar', length: 100 })
+  city: string;
+
+  @Column({ type: 'varchar', length: 2 })
+  state: string;
+
+  @Column({
+    type: 'enum',
+    enum: Object.values(TournamentGender),
+  })
+  gender: TournamentGender;
+
+  @Column({ name: 'deleted_at', type: 'timestamptz', nullable: true })
+  deletedAt: Date | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o esquema de partidas associado ao torneio.
+   */
+  @ManyToOne(() => TournamentMatchSchema, (matchSchema) => matchSchema.tournaments, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'match_schema_id' })
+  matchSchema: TournamentMatchSchema;
+
+  /**
+   * Relação com os times associados ao torneio.
+   */
+  @OneToMany(() => TournamentTeam, (team) => team.tournament)
+  teams: TournamentTeam[];
+
+  /**
+   * Relação com as regras do torneio.
+   */
+  @OneToOne(() => TournamentRule, (rule) => rule.tournament, { cascade: true })
+  @JoinColumn({ name: 'rule_id' })
+  rule: TournamentRule;
+
+  /**
+   * Relação com o formato do torneio.
+   */
+  @OneToOne(() => TournamentFormatConfig, (format) => format.tournament, { cascade: true })
+  @JoinColumn({ name: 'format_config_id' })
+  format: TournamentFormatConfig;
+
+  /**
+   * Relação com as regras de premiação associadas ao torneio.
+   */
+  @OneToMany(() => TournamentPrizeRule, (prizeRule) => prizeRule.tournament)
+  prizeRules: TournamentPrizeRule[];
+
+  /**
+   * Relação com os pagamentos associados ao torneio.
+   */
+  @OneToMany(() => TournamentPayment, (payment) => payment.tournament)
+  payments: TournamentPayment[];
+
+  /**
+   * Relação com as partidas associadas ao torneio.
+   */
+  @OneToMany(() => TournamentMatch, (match) => match.tournament)
+  matches: TournamentMatch[];
+
+  /**
+   * Relação com os estabelecimentos associadas ao torneio.
+   */
+  @OneToMany(() => TournamentFacility, (facility) => facility.tournament)
+  tournamentFacilities: TournamentFacility[];
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "module": "ESNext",
+    "target": "ES2021",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "removeComments": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strictPropertyInitialization": false,
+    "baseUrl": "./src"
+  },
+
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}