pro-clubs-shared-dtos 3.0.0

package/src/dtos/responses/transfer-dtos.ts

@@ -0,0 +1,66 @@
+// Transfer Request DTO
+export interface TransferRequestDTO {
+  id: string;
+  playerId: string;
+  fromTeamId: string | null; // null for free agents
+  toTeamId: string;
+  requestedBy: string;
+  status: string; // TRANSFER_REQUEST_STATUS
+  requestedAt: Date;
+  processedAt?: Date;
+  processedBy?: string;
+  reason?: string;
+  message?: string;
+  expiresAt: Date;
+  player?: {
+    id: string;
+    name: string;
+    position: string;
+    imgUrl?: string;
+  };
+  fromTeam?: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+  toTeam?: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+  requester?: {
+    firstName: string;
+    lastName: string;
+    email: string;
+  };
+  processor?: {
+    firstName: string;
+    lastName: string;
+    email: string;
+  };
+}
+
+// Paginated Transfer Requests DTO
+export interface PaginatedTransferRequestsDTO {
+  data: TransferRequestDTO[];
+  page: number;
+  pageSize: number;
+  totalItems: number;
+  totalPages: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+}
+
+// Create Transfer Request DTO
+export interface CreateTransferRequestDTO {
+  playerId: string;
+  fromTeamId?: string | null;
+  toTeamId: string;
+  message?: string;
+}
+
+// Process Transfer Request DTO
+export interface ProcessTransferRequestDTO {
+  action: 'approve' | 'reject';
+  reason?: string;
+}

package/src/dtos/transfer-request/index.ts

@@ -0,0 +1 @@
+export * from '../responses/transfer-dtos';

package/src/enums/extended-game-status.ts

@@ -0,0 +1,15 @@
+/**
+ * Extended Game Status enum that includes all possible game statuses
+ * used throughout the Pro Clubs Manager application.
+ */
+export enum EXTENDED_GAME_STATUS {
+  SCHEDULED = "Scheduled",
+  POSTPONED = "Postponed",
+  CANCELLED = "Cancelled",
+  PLAYED = "Played",
+  COMPLETED = "Completed",
+  LINEUP_AVAILABLE = "LineupAvailable"
+}
+
+// Alias for backward compatibility
+export const GAME_STATUS = EXTENDED_GAME_STATUS;

package/src/index.ts

@@ -0,0 +1,28 @@
+// Export all Models - Pure Data Types with NO SERVICE/CONTROLLER/REPOSITORY Dependencies
+export * from './models/user';
+export * from './models/team';
+export * from './models/player/player';
+export * from './models/player/player-types';
+export * from './models/game/game';
+export * from './models/game/game-types';
+export * from './models/game/ea-game-details';
+export * from './models/game/player-validation';
+export * from './models/league';
+export * from './models/fixture';
+export * from './models/event';
+export * from './models/news';
+export * from './models/notification';
+export * from './models/chat';
+export * from './models/ban';
+export * from './models/prediction/prediction';
+export * from './models/transfer-request';
+export * from './models/season-achievement';
+export * from './models/team-of-the-season';
+export * from './models/player-association-request';
+export * from './models/comment/comment';
+
+// Export Enums
+export * from './enums/extended-game-status';
+
+// Export Error Interfaces
+export * from './dtos/api-error-response';

package/src/models/ban.ts

@@ -0,0 +1,70 @@
+import mongoose, { Schema, Document } from "mongoose";
+
+export interface IBan extends Document {
+  playerId: mongoose.Types.ObjectId;
+  reason: string;
+  expireDate: Date;
+  createdAt: Date;
+  givenBy: mongoose.Types.ObjectId; // User who created the ban
+  isActive: boolean; // true if the ban is still active, false if lifted
+  liftedAt?: Date; // When the ban was lifted (if applicable)
+  liftedBy?: mongoose.Types.ObjectId; // Who lifted the ban
+  liftReason?: string; // Why the ban was lifted
+}
+
+const banSchema = new Schema<IBan>({
+  playerId: {
+    type: Schema.Types.ObjectId,
+    ref: "Player",
+    required: true,
+    index: true
+  },
+  reason: {
+    type: String,
+    required: true
+  },
+  expireDate: {
+    type: Date,
+    required: true,
+    index: true
+  },
+  createdAt: {
+    type: Date,
+    default: () => new Date(),
+    required: true,
+    index: true
+  },
+  givenBy: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+  isActive: {
+    type: Boolean,
+    default: true,
+    required: true,
+    index: true
+  },
+  liftedAt: {
+    type: Date,
+    default: null
+  },
+  liftedBy: {
+    type: Schema.Types.ObjectId,
+    ref: "User"
+  },
+  liftReason: {
+    type: String,
+    default: null
+  }
+});
+
+// Ensure unique index on active bans per player
+banSchema.index({ playerId: 1, isActive: 1 });
+
+// Create compound index for efficient queries
+banSchema.index({ playerId: 1, expireDate: 1, isActive: 1 });
+
+const Ban = mongoose.model<IBan>("Ban", banSchema);
+
+export default Ban;

package/src/models/chat.ts

@@ -0,0 +1,89 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface IChatMessage extends Document {
+  content: string;
+  author: {
+    id: string;
+    firstName: string;
+    lastName: string;
+    profilePicture?: string;
+    role: 'user' | 'admin';
+  };
+  timestamp: Date;
+  edited: boolean;
+  editedAt?: Date;
+  replyTo?: string; // ID of message being replied to
+  reactions: {
+    emoji: string;
+    users: string[]; // User IDs who reacted
+  }[];
+  isDeleted: boolean;
+  deletedAt?: Date;
+  deletedBy?: string;
+}
+
+const chatMessageSchema = new Schema<IChatMessage>(
+  {
+    content: { 
+      type: String, 
+      required: true,
+      maxlength: 1000,
+      trim: true
+    },
+    author: {
+      id: { type: String, required: true },
+      firstName: { type: String, required: true },
+      lastName: { type: String, required: true },
+      profilePicture: { type: String },
+      role: { 
+        type: String, 
+        enum: ['user', 'admin'], 
+        required: true 
+      }
+    },
+    timestamp: { 
+      type: Date, 
+      default: Date.now,
+      required: true
+    },
+    edited: { 
+      type: Boolean, 
+      default: false 
+    },
+    editedAt: { 
+      type: Date 
+    },
+    replyTo: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: 'ChatMessage' 
+    },
+    reactions: [{
+      emoji: { type: String, required: true },
+      users: [{ type: String, required: true }]
+    }],
+    isDeleted: { 
+      type: Boolean, 
+      default: false 
+    },
+    deletedAt: { 
+      type: Date 
+    },
+    deletedBy: { 
+      type: String 
+    }
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    id: true
+  }
+);
+
+// Index for efficient querying
+chatMessageSchema.index({ timestamp: -1 });
+chatMessageSchema.index({ 'author.id': 1 });
+chatMessageSchema.index({ isDeleted: 1 });
+
+const ChatMessage = mongoose.model<IChatMessage>('ChatMessage', chatMessageSchema);
+
+export default ChatMessage;

package/src/models/comment/comment.ts

@@ -0,0 +1,62 @@
+import { Schema, model, Types, Document } from "mongoose";
+
+export interface IComment extends Document {
+  _id: Types.ObjectId;
+  gameId: Types.ObjectId;
+  userId: Types.ObjectId;
+  content: string;
+  parentCommentId?: Types.ObjectId;
+  likes: Types.ObjectId[]; // Array of user IDs who liked this comment
+  isEdited: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const commentSchema = new Schema<IComment>({
+  gameId: {
+    type: Schema.Types.ObjectId,
+    ref: "Game",
+    required: true,
+    index: true
+  },
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+    index: true
+  },
+  content: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 1000 // Limit comment length
+  },
+  parentCommentId: {
+    type: Schema.Types.ObjectId,
+    ref: "Comment",
+    default: null,
+    index: true
+  },
+  likes: [{
+    type: Schema.Types.ObjectId,
+    ref: "User"
+  }],
+  isEdited: {
+    type: Boolean,
+    default: false
+  }
+}, {
+  timestamps: true,
+  collection: "comments"
+});
+
+// Index for efficient querying by game
+commentSchema.index({ gameId: 1, createdAt: -1 });
+
+// Index for efficient querying of replies
+commentSchema.index({ parentCommentId: 1, createdAt: 1 });
+
+// Index for user's comments
+commentSchema.index({ userId: 1, createdAt: -1 });
+
+export const Comment = model<IComment>("Comment", commentSchema);

package/src/models/event.ts

@@ -0,0 +1,137 @@
+import mongoose, { Schema, Document } from "mongoose";
+import { SERIES_FORMAT } from "./game/game";
+
+export enum EVENT_TYPE {
+  ALL_STAR = "ALL_STAR"
+}
+
+export enum EVENT_STATUS {
+  DRAFT = "draft",
+  REGISTRATION = "registration",
+  DRAFT_IN_PROGRESS = "draft_in_progress",
+  COMPLETED = "completed"
+}
+
+export interface IAllStarDraftTeam {
+  id: string;
+  name: string;
+  captainId: mongoose.Types.ObjectId;
+  players: mongoose.Types.ObjectId[];
+}
+
+export interface IAllStarDraftConfig {
+  numberOfCaptains: number;
+  matchFormat: SERIES_FORMAT;
+  registrationOpenDate: Date;
+  registrationCloseDate: Date;
+  teams?: IAllStarDraftTeam[];
+  captainIds?: mongoose.Types.ObjectId[];
+}
+
+export interface IEventStats {
+  playerId: mongoose.Types.ObjectId;
+  goals: number;
+  assists: number;
+  appearances: number;
+  playerOfTheMatch: number;
+  avgRating: number;
+}
+
+export interface IEvent extends Document {
+  id: string;
+  name: string;
+  type: EVENT_TYPE;
+  league: mongoose.Types.ObjectId;
+  seasonNumber: number;
+  date: Date;
+  status: EVENT_STATUS;
+  createdBy: mongoose.Types.ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+
+  // All-Star specific fields
+  allStarConfig?: IAllStarDraftConfig;
+  registeredPlayers?: mongoose.Types.ObjectId[];
+  fixtures?: mongoose.Types.ObjectId[]; // Event-specific fixtures/games
+  stats?: IEventStats[]; // Track all-star specific statistics
+  
+  // Event outcome
+  winnerTeam?: IAllStarDraftTeam;
+  completedDate?: Date;
+}
+
+const allStarTeamSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    name: { type: String, required: true },
+    captainId: { type: mongoose.Schema.Types.ObjectId, ref: "Player", required: true },
+    players: [{ type: mongoose.Schema.Types.ObjectId, ref: "Player" }],
+  },
+  { _id: false }
+);
+
+const allStarDraftConfigSchema = new Schema(
+  {
+    numberOfCaptains: { type: Number, required: true },
+    matchFormat: {
+      type: String,
+      enum: Object.values(SERIES_FORMAT),
+      required: true,
+    },
+    registrationOpenDate: { type: Date, required: true },
+    registrationCloseDate: { type: Date, required: true },
+    teams: [allStarTeamSchema],
+    captainIds: [{ type: mongoose.Schema.Types.ObjectId, ref: "Player" }],
+  },
+  { _id: false }
+);
+
+const eventStatsSchema = new Schema(
+  {
+    playerId: { type: mongoose.Schema.Types.ObjectId, ref: "Player", required: true },
+    goals: { type: Number, default: 0 },
+    assists: { type: Number, default: 0 },
+    appearances: { type: Number, default: 0 },
+    playerOfTheMatch: { type: Number, default: 0 },
+    avgRating: { type: Number, default: 0 },
+  },
+  { _id: false }
+);
+
+const eventSchema = new Schema<IEvent>(
+  {
+    name: { type: String, required: true },
+    type: { type: String, enum: Object.values(EVENT_TYPE), required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League", required: true },
+    seasonNumber: { type: Number, required: true },
+    date: { type: Date, required: true },
+    status: { type: String, enum: Object.values(EVENT_STATUS), required: true, default: EVENT_STATUS.DRAFT },
+    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "Player", required: true },
+    createdAt: { type: Date, required: true, default: Date.now },
+    updatedAt: { type: Date, required: true, default: Date.now },
+
+    // All-Star specific fields
+    allStarConfig: allStarDraftConfigSchema,
+    registeredPlayers: { type: [{ type: mongoose.Schema.Types.ObjectId, ref: "Player" }], default: [] },
+    fixtures: [{ type: mongoose.Schema.Types.ObjectId, ref: "Fixture" }],
+    stats: [eventStatsSchema],
+
+    // Event outcome
+    winnerTeam: allStarTeamSchema,
+    completedDate: { type: Date },
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true,
+  }
+);
+
+// Indexes for common queries
+eventSchema.index({ league: 1, seasonNumber: 1 });
+eventSchema.index({ status: 1 });
+eventSchema.index({ type: 1 });
+eventSchema.index({ createdAt: -1 });
+
+const Event = mongoose.model<IEvent>("Event", eventSchema);
+
+export default Event;

package/src/models/fixture.ts

@@ -0,0 +1,52 @@
+import mongoose, { Schema, Document } from "mongoose";
+import { AddGameData, PlayoffDetails } from "./game/game";
+
+export interface AddFixtureData {
+  leagueId: mongoose.Types.ObjectId;
+  seasonNumber: number;
+  gamesData: AddGameData[];
+  round: number;
+  startDate: Date;
+  endDate: Date;
+  isPlayoff?: boolean;
+  playoffDetails?: PlayoffDetails;
+}
+
+export interface IFixture extends Document {
+  id: string;
+  league: mongoose.Types.ObjectId;
+  seasonNumber: number;
+  round: number;
+  startDate: Date;
+  endDate: Date;
+  games: mongoose.Types.ObjectId[];
+  isPlayoff?: boolean;
+  playoffDetails?: PlayoffDetails;
+}
+
+const fixtureSchema = new Schema<IFixture>(
+  {
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League", required: true },
+    round: { type: Number, required: true },
+    seasonNumber: { type: Number, required: true },
+    startDate: { type: mongoose.Schema.Types.Date, required: true },
+    endDate: { type: mongoose.Schema.Types.Date, required: true },
+    games: [{ type: mongoose.Schema.Types.ObjectId, ref: "Game", required: true }],
+    isPlayoff: { type: Boolean, required: false, default: false },
+    playoffDetails: {
+      type: {
+        stage: { type: String, required: true },
+        format: { type: String, required: true }
+      },
+      required: false
+    },
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true, // Use 'id' instead of '_id'
+  }
+);
+
+const Fixture = mongoose.model<IFixture>("Fixture", fixtureSchema);
+
+export default Fixture;

package/src/models/game/ea-game-details.ts

@@ -0,0 +1,124 @@
+/**
+ * Clean EA Game Statistics - Simplified statistics sent to client and stored in database
+ * Contains only essential performance metrics from both teams
+ */
+export interface EAGameStatistics {
+  goals: number;
+  assists: number;
+  passesMade: number;
+  passAttempts: number;
+  redcards: number;
+  saves: number;
+  shots: number;
+  tackleattempts: number;
+  tacklesmade: number;
+  tackleSuccessRate: number; // (tacklesmade / tackleattempts) * 100, rounded to 2 decimals
+  passSuccessRate: number;   // (passesMade / passAttempts) * 100, rounded to 2 decimals
+}
+
+/**
+ * Internal aggregate stats used for processing from EA API
+ * This is used internally but not sent to client
+ */
+export interface EAGameAggregateStats {
+  archetypeid: number;
+  assists: number;
+  ballDiveSaves: number;
+  cleansheetsany: number;
+  cleansheetsdef: number;
+  cleansheetsgk: number;
+  crossSaves: number;
+  gameTime: number;
+  goals: number;
+  goalsconceded: number;
+  goodDirectionSaves: number;
+  losses: number;
+  match_event_aggregate_0: number;
+  match_event_aggregate_1: number;
+  match_event_aggregate_2: number;
+  match_event_aggregate_3: number;
+  mom: number;
+  namespace: number;
+  parrySaves: number;
+  passattempts: number;
+  passesmade: number;
+  pos: number;
+  punchSaves: number;
+  rating: number;
+  realtimegame: number;
+  realtimeidle: number;
+  redcards: number;
+  reflexSaves: number;
+  saves: number;
+  SCORE: number;
+  secondsPlayed: number;
+  shots: number;
+  tackleattempts: number;
+  tacklesmade: number;
+  userResult: number;
+  vproattr: number;
+  vprohackreason: number;
+  wins: number;
+}
+
+/**
+ * EA Game Details stored in database
+ * Contains simplified statistics for both teams
+ */
+export interface EAGameDetails {
+  eaMatchId?: string;
+  fetchedAt?: Date;
+  homeTeamStats?: EAGameStatistics;
+  awayTeamStats?: EAGameStatistics;
+  homeTeamAggregateStats?: EAGameAggregateStats;
+  awayTeamAggregateStats?: EAGameAggregateStats;
+}
+
+/**
+ * Internal representation of raw EA API response
+ * Used temporarily during processing but not stored
+ */
+export interface EAApiResponse {
+  // EA Match ID
+  matchId: string;
+
+  // Club details - keyed by EA Team ID
+  clubs?: {
+    [eaTeamId: string]: {
+      date: string;
+      gameNumber: string;
+      goals: string;
+      goalsAgainst: string;
+      losses: string;
+      matchType: string;
+      result: string;
+      score: string;
+      season_id: string;
+      TEAM: string;
+      ties: string;
+      winnerByDnf: string;
+      wins: string;
+      details?: {
+        name: string;
+        clubId: number;
+        regionId: number;
+        teamId: number;
+        customKit?: any;
+      };
+    };
+  };
+
+  // Team aggregate statistics - keyed by EA Team ID
+  aggregate: {
+    [eaTeamId: string]: EAGameAggregateStats;
+  };
+
+  // Timestamp of the match
+  timestamp: number;
+
+  // Time ago information
+  timeAgo?: {
+    number: number;
+    unit: string;
+  };
+}

package/src/models/game/game-types.ts

@@ -0,0 +1,46 @@
+import { Types } from "mongoose";
+import { PLAYOFF_STAGE } from "./game";
+
+export type AddGameData = {
+  homeTeam: Types.ObjectId;
+  awayTeam: Types.ObjectId;
+  date?: Date;
+  round?: number;
+  isPlayoff?: boolean;
+  playoffStage?: PLAYOFF_STAGE;
+  matchNumber?: number;
+};
+
+export type PlayerGamePerformance = {
+  playerId: Types.ObjectId;
+  rating: number;
+  playerOfTheMatch?: boolean;
+  goals?: number;
+  assists?: number;
+  cleanSheet: boolean;
+  positionPlayed: string;
+  formation?: string;
+  isBotPlayer?: boolean; // Flag to identify BOT players
+};
+
+type PopulatedBasicInfo = {
+  id: string;
+  name: string;
+  imgUrl?: string;
+};
+
+export type PopulatedPlayerGameData = {
+  id: string;
+  league: PopulatedBasicInfo;
+  seasonNumber: number;
+  round: number;
+  date?: Date;
+  result?: {
+    homeTeamGoals: number;
+    awayTeamGoals: number;
+  };
+  homeTeam: PopulatedBasicInfo;
+  awayTeam: PopulatedBasicInfo;
+  homeTeamPlayersPerformance: PlayerGamePerformance[];
+  awayTeamPlayersPerformance: PlayerGamePerformance[];
+};