pro-clubs-shared-dtos 3.0.0

package/src/models/game/game.ts

@@ -0,0 +1,170 @@
+import { GAME_STATUS, EXTENDED_GAME_STATUS } from "../../enums/extended-game-status";
+import mongoose, { Document, Schema } from "mongoose";
+import { PlayerGamePerformance } from "./game-types";
+import { EAGameDetails } from "./ea-game-details";
+
+export enum PLAYOFF_STAGE {
+  PLAY_IN_ROUND = "Play-in Round",
+  QUARTER_FINAL = "Quarter-Final",
+  SEMI_FINAL = "Semi-Final",
+  FINAL = "Final",
+  THIRD_PLACE = "3rd Place Match",
+  PROMOTION_PLAYOFF = "Promotion Playoff",
+  RELEGATION_PLAYOFF = "Relegation Playoff"
+}
+
+export enum SERIES_FORMAT {
+  BEST_OF_1 = "Best of 1",
+  BEST_OF_3 = "Best of 3",
+  BEST_OF_5 = "Best of 5",
+  BEST_OF_7 = "Best of 7"
+}
+
+export interface PlayoffDetails {
+  stage: PLAYOFF_STAGE;
+  format: SERIES_FORMAT;
+}
+
+export interface IGame extends Document {
+  id: string;
+  fixture: mongoose.Types.ObjectId;
+  round: number;
+  league: mongoose.Types.ObjectId;
+  seasonNumber: number;
+  homeTeam: mongoose.Types.ObjectId;
+  awayTeam: mongoose.Types.ObjectId;
+  date?: Date;
+  status: EXTENDED_GAME_STATUS;
+  isPlayoff: boolean;
+  playoffStage?: PLAYOFF_STAGE;
+  matchNumber?: number;
+  technicalLoss?: {
+    teamId: mongoose.Types.ObjectId;
+    reason: string;
+  };
+  result?: {
+    homeTeamGoals: number;
+    awayTeamGoals: number;
+    penalties?: {
+      homeTeamPenalties: number;
+      awayTeamPenalties: number;
+    };
+  };
+  broadcast?: {
+    streamUrl: string;
+    broadcastingTeam: string;
+  };
+  homeTeamPlayersPerformance?: PlayerGamePerformance[];
+  awayTeamPlayersPerformance?: PlayerGamePerformance[];
+  homeTeamLineupSent?: boolean;
+  homeTeamLineupSentAt?: Date;
+  awayTeamLineupSent?: boolean;
+  awayTeamLineupSentAt?: Date;
+  aiAnalysisImage?: string; // URL to the saved AI analysis image (deprecated - use team-specific fields)
+  homeTeamPlayersImage?: string; // URL to the home team's player stats screenshot
+  awayTeamPlayersImage?: string; // URL to the away team's player stats screenshot
+  eaGameDetails?: EAGameDetails; // EA game details from Clubs API
+  playerValidationResult?: any; // Player eligibility validation result from EA match data
+}
+
+const playerGameStatsSchema = new Schema(
+  {
+    playerId: { type: mongoose.Schema.Types.ObjectId, ref: "Player", required: true },
+    rating: { type: Number, required: true },
+    cleanSheet: { type: Boolean, required: true },
+    goals: { type: Number },
+    assists: { type: Number },
+    playerOfTheMatch: { type: Boolean },
+    positionPlayed: { type: String },
+    isBotPlayer: { type: Boolean, default: false }, // Flag to identify BOT players
+  },
+  { id: false }
+);
+
+const gameSchema = new Schema<IGame>(
+  {
+    fixture: { type: mongoose.Schema.Types.ObjectId, ref: "Fixture", required: true },
+    round: { type: Number, required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League", required: true },
+    seasonNumber: { type: Number, required: true },
+    homeTeam: { type: mongoose.Schema.Types.ObjectId, ref: "Team", required: true },
+    awayTeam: { type: mongoose.Schema.Types.ObjectId, ref: "Team", required: true },
+    date: { type: Date },
+    status: { type: String, required: true, default: EXTENDED_GAME_STATUS.SCHEDULED, enum: Object.values(EXTENDED_GAME_STATUS) },
+    isPlayoff: { type: Boolean, required: true, default: false },
+    playoffStage: { type: String, enum: Object.values(PLAYOFF_STAGE), required: false },
+    matchNumber: { type: Number, required: false },
+    technicalLoss: {
+      type: {
+        reason: { type: String, required: true },
+        teamId: { type: mongoose.Schema.Types.ObjectId, ref: "Team", required: true },
+      },
+      id: false,
+      required: false,
+    },
+    result: {
+      type: {
+        homeTeamGoals: { type: Number },
+        awayTeamGoals: { type: Number },
+        penalties: {
+          type: {
+            homeTeamPenalties: { type: Number },
+            awayTeamPenalties: { type: Number },
+          },
+          required: false,
+        },
+      },
+      required: false,
+    },
+    broadcast: {
+      type: {
+        streamUrl: { type: String, required: true },
+        broadcastingTeam: { type: String, required: true },
+      },
+      required: false,
+    },
+    homeTeamPlayersPerformance: [playerGameStatsSchema],
+    awayTeamPlayersPerformance: [playerGameStatsSchema],
+    homeTeamLineupSent: { type: Boolean, required: false, default: false },
+    homeTeamLineupSentAt: { type: Date, required: false },
+    awayTeamLineupSent: { type: Boolean, required: false, default: false },
+    awayTeamLineupSentAt: { type: Date, required: false },
+    aiAnalysisImage: { type: String, required: false }, // URL to the saved AI analysis image (deprecated)
+    homeTeamPlayersImage: { type: String, required: false }, // URL to the home team's player stats screenshot
+    awayTeamPlayersImage: { type: String, required: false }, // URL to the away team's player stats screenshot
+    eaGameDetails: {
+      type: {
+        eaMatchId: { type: String, required: false },
+        fetchedAt: { type: Date, required: false },
+        homeTeamStats: { type: Schema.Types.Mixed, required: false },
+        awayTeamStats: { type: Schema.Types.Mixed, required: false },
+        lastFetchedJob: {
+          type: {
+            jobId: { type: String, required: true },
+            scheduledFor: { type: Date, required: true },
+            executedAt: { type: Date, required: false }
+          },
+          required: false
+        }
+      },
+      required: false
+    },
+    playerValidationResult: {
+      type: Schema.Types.Mixed,
+      required: false
+    },
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true, // Use 'id' instead of '_id'
+  }
+);
+
+// Define the index
+gameSchema.index({ league: 1, seasonNumber: 1, date: 1 });
+gameSchema.index({ GAME_STATUS: 1 });
+
+const Game = mongoose.model<IGame>("Game", gameSchema);
+
+export default Game;
+export { PlayerGamePerformance, AddGameData, PopulatedPlayerGameData } from "./game-types";

package/src/models/game/player-validation.ts

@@ -0,0 +1,262 @@
+/**
+ * IPL Player Validation Feature - Interfaces and Types
+ *
+ * This module defines the data structures and types needed for validating
+ * player eligibility when processing match data from the EA API.
+ */
+
+import mongoose from "mongoose";
+
+/**
+ * EA API Player Data structure as returned from the API
+ * Contains player-level statistics from a specific match
+ */
+export interface EAPlayerData {
+  gamerTag: string;
+  playerName: string;
+  position: string;
+  rating: number;
+  goals?: number;
+  assists?: number;
+  saves?: number;
+  [key: string]: any; // Allow additional EA stats
+}
+
+/**
+ * Result of validating a single player against team squad
+ */
+export interface PlayerValidationResult {
+  gamerTag: string;
+  playerName: string;
+  position: string;
+  found: boolean;
+  matchedPlayerId?: string; // ObjectId of matched player in our system
+  reason?: string; // Reason if not found
+}
+
+/**
+ * Validation results for all players from one team
+ */
+export interface TeamValidationResult {
+  teamId: string;
+  eaTeamId: string;
+  teamName: string;
+  allPlayersVerified: boolean;
+  verifiedPlayerCount: number;
+  ineligiblePlayerCount: number;
+  playerValidations: PlayerValidationResult[];
+}
+
+/**
+ * Summary of a complete match validation
+ * Shows if match is valid and if technical win should be awarded
+ */
+export interface MatchValidationResult {
+  matchId: string;
+  eaMatchId: string;
+  validationTimestamp: Date;
+  status: "valid" | "invalid";
+  homeTeam: TeamValidationResult;
+  awayTeam: TeamValidationResult;
+  ineligiblePlayers: Array<EAPlayerData & { team: string }>;
+  technicalWinAward?: {
+    awardedToTeamId: string;
+    awardedToTeamName: string;
+    reason: string;
+    ineligiblePlayerCount: number;
+  };
+}
+
+/**
+ * Enriched player performance data from EA API match
+ * Stored for future seasons' use
+ */
+export interface EnrichedPlayerMatchData {
+  playerId: string;
+  gamerTag: string;
+  playerName: string;
+  position: string;
+  eaStats: {
+    rating: number;
+    goals?: number;
+    assists?: number;
+    saves?: number;
+    [key: string]: any;
+  };
+  matchDate: Date;
+  opponent: {
+    teamId: string;
+    teamName: string;
+  };
+}
+
+/**
+ * Complete enriched match data structure
+ * Contains validation results and enriched player data
+ */
+export interface EnrichedMatchData {
+  gameId: string;
+  eaMatchId: string;
+  matchDate: Date;
+  validationResult: MatchValidationResult;
+  enrichedPlayerData?: {
+    homeTeam: EnrichedPlayerMatchData[];
+    awayTeam: EnrichedPlayerMatchData[];
+  };
+  matchResult: {
+    homeGoals: number;
+    awayGoals: number;
+    winner: "home" | "away" | "draw";
+    isTechnicalWin: boolean;
+    technicalWinReason?: string;
+  };
+  storedAt: Date;
+}
+
+/**
+ * Request object for player validation
+ * Contains all necessary data to validate a match's players
+ */
+export interface PlayerValidationRequest {
+  matchId: string;
+  eaMatchId: string;
+  matchDate: Date;
+  homeTeam: {
+    teamId: string;
+    eaTeamId: string;
+    teamName: string;
+    players: EAPlayerData[];
+  };
+  awayTeam: {
+    teamId: string;
+    eaTeamId: string;
+    teamName: string;
+    players: EAPlayerData[];
+  };
+  matchResult: {
+    homeGoals: number;
+    awayGoals: number;
+  };
+}
+
+/**
+ * Database schema interface for storing validation results
+ * Extends Mongoose Document
+ */
+export interface IMatchValidationRecord extends mongoose.Document {
+  gameId: mongoose.Types.ObjectId;
+  eaMatchId: string;
+  matchDate: Date;
+  validationResult: MatchValidationResult;
+  enrichedPlayerData?: {
+    homeTeam: EnrichedPlayerMatchData[];
+    awayTeam: EnrichedPlayerMatchData[];
+  };
+  matchResult: {
+    homeGoals: number;
+    awayGoals: number;
+    winner: "home" | "away" | "draw";
+    isTechnicalWin: boolean;
+    technicalWinReason?: string;
+  };
+  storedAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Audit log entry for tracking validation and technical wins
+ */
+export interface ValidationAuditLog {
+  matchId: string;
+  eaMatchId: string;
+  validationTimestamp: Date;
+  status: "VALID" | "INVALID" | "REJECTED_DUE_TO_INELIGIBLE_PLAYERS";
+  ineligiblePlayerCount: number;
+  technicalWinAwarded?: {
+    teamId: string;
+    teamName: string;
+  };
+  adminReviewRequired: boolean;
+  severity?: "LOW" | "MEDIUM" | "HIGH"; // HIGH for multiple ineligible players
+  notes?: string;
+}
+
+/**
+ * Statistics for a season showing validation patterns
+ */
+export interface ValidationStatistics {
+  season: number;
+  totalMatchesValidated: number;
+  validMatches: number;
+  invalidMatches: number;
+  technicalWinsAwarded: number;
+  totalIneligiblePlayersDetected: number;
+  teamsWithViolations: Array<{
+    teamId: string;
+    teamName: string;
+    violationCount: number;
+    ineligiblePlayerCount: number;
+  }>;
+}
+
+/**
+ * Example validation data for testing/documentation
+ */
+export const VALIDATION_EXAMPLES = {
+  // Scenario 1: Valid match
+  validMatch: {
+    matchId: "match_valid_001",
+    status: "valid",
+    description:
+      "All 22 players from both teams are found in their respective squads",
+    homeTeamPlayers: 11,
+    awayTeamPlayers: 11,
+    ineligiblePlayers: 0,
+    technicalWin: null,
+  } as const,
+
+  // Scenario 2: Single ineligible player
+  singleIneligiblePlayer: {
+    matchId: "match_invalid_001",
+    status: "invalid",
+    description:
+      "Away team fielded 1 player not in their registered squad",
+    homeTeamPlayers: 11,
+    awayTeamPlayers: 10,
+    ineligiblePlayers: 1,
+    technicalWin: "home team",
+  } as const,
+
+  // Scenario 3: Multiple ineligible players
+  multipleIneligiblePlayers: {
+    matchId: "match_invalid_002",
+    status: "invalid",
+    description: "Away team fielded 3 players not in their registered squad",
+    homeTeamPlayers: 11,
+    awayTeamPlayers: 8,
+    ineligiblePlayers: 3,
+    technicalWin: "home team",
+  } as const,
+};
+
+/**
+ * Technical win award details
+ * Used when a team fields ineligible players
+ */
+export interface TechnicalWinAward {
+  awardedToTeamId: string;
+  awardedToTeamName: string;
+  awardedAt: Date;
+  reason: string;
+  ineligiblePlayerCount: number;
+  matchId: string;
+  eaMatchId: string;
+  originalEAScore?: {
+    homeGoals: number;
+    awayGoals: number;
+  };
+  technicalWinScore: {
+    homeGoals: number;
+    awayGoals: number;
+  };
+}

package/src/models/league.ts

@@ -0,0 +1,71 @@
+import mongoose, { Schema, Document } from "mongoose";
+
+enum Role {
+  OWNER = "OWNER",
+  MANAGER = "MANAGER",
+  MODERATOR = "MODERATOR",
+}
+
+interface ILeagueAdmin {
+  playerId: mongoose.Types.ObjectId;
+  role: Role;
+}
+
+export interface ILeague extends Document {
+  id: string;
+  name: string;
+  imgUrl?: string;
+  teams: mongoose.Types.ObjectId[];
+  // admins: ILeagueAdmin[];
+  seasonsHistory: ILeagueSeason[];
+  currentSeason: ILeagueSeason;
+}
+
+export interface ILeagueSeason {
+  seasonNumber: number;
+  winner: mongoose.Types.ObjectId | null;
+  fixtures: mongoose.Types.ObjectId[];
+  teams?: mongoose.Types.ObjectId[];
+  startDate: Date;
+  endDate?: Date;
+}
+
+const leagueSeasonSchema = new Schema(
+  {
+    seasonNumber: { type: Number, required: true },
+    winner: { type: mongoose.Schema.Types.ObjectId, ref: "Team", default: null },
+    teams: [{ type: mongoose.Schema.Types.ObjectId, ref: "Team" }],
+    fixtures: [{ type: mongoose.Schema.Types.ObjectId, ref: "Fixture" }],
+    startDate: { type: mongoose.Schema.Types.Date, required: true },
+    endDate: { type: mongoose.Schema.Types.Date },
+  },
+  { _id: false }
+);
+
+const leagueSchema: Schema = new Schema<ILeague>(
+  {
+    name: { type: String, required: true, unique: true },
+    imgUrl: { type: String },
+    teams: [{ type: mongoose.Schema.Types.ObjectId, ref: "Team" }],
+    seasonsHistory: [leagueSeasonSchema],
+    currentSeason: leagueSeasonSchema,
+    // admins: [
+    //   {
+    //     playerId: {
+    //       type: mongoose.Types.ObjectId,
+    //       required: true,
+    //       ref: "Player",
+    //     },
+    //     role: { type: String, enum: Object.values(Role), required: true },
+    //   },
+    // ],
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true, // Use 'id' instead of '_id'
+  }
+);
+
+const League = mongoose.model<ILeague>("League", leagueSchema);
+
+export default League;

package/src/models/news.ts

@@ -0,0 +1,130 @@
+// models/news.ts
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface ITransferData {
+  playerDetails: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+  fromTeam: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+  toTeam: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+}
+
+export interface IFreeAgentData {
+  playerDetails: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+    position: string;
+    age: number;
+  };
+  previousTeams: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+    seasonNumber: number;
+  }[];
+}
+
+// Define the interface for the news item
+export interface INews extends Document {
+  title: string;
+  content: string;
+  type: 'General' | 'Transfer' | 'FreeAgent';
+  createdBy: string;
+  createdAt: Date;
+  transferData?: ITransferData;
+  freeAgentData?: IFreeAgentData;
+  likes: string[]; // Array of user IDs who liked this news
+  likeCount: number; // Computed field for like count
+}
+
+const transferDataSchema = new Schema(
+  {
+    playerDetails: {
+      id: { type: String, required: true },
+      name: { type: String, required: true },
+      imgUrl: { type: String },
+    },
+    fromTeam: {
+      id: { type: String },
+      name: { type: String },
+      imgUrl: { type: String },
+    },
+    toTeam: {
+      id: { type: String, required: true },
+      name: { type: String, required: true },
+      imgUrl: { type: String },
+    }
+  },
+  { _id: false }
+);
+
+const freeAgentDataSchema = new Schema(
+  {
+    playerDetails: {
+      id: { type: String, required: true },
+      name: { type: String, required: true },
+      imgUrl: { type: String, required: false },
+      position: { type: String, required: true },
+      age: { type: Number, required: true },
+    },
+    previousTeams: [{
+      id: { type: String, required: true },
+      name: { type: String, required: true },
+      imgUrl: { type: String, required: false },
+      seasonNumber: { type: Number, required: true },
+    }],
+  },
+  { _id: false }
+);
+
+const newsSchema = new Schema(
+  {
+    title: { type: String, required: true },
+    content: { type: String, required: true },
+    type: {
+      type: String,
+      enum: ['General', 'Transfer', 'FreeAgent'],
+      required: true
+    },
+    createdBy: { type: String, required: true },
+    createdAt: { type: Date, default: Date.now },
+    likes: { type: [String], default: [] }, // Array of user IDs
+    transferData: {
+      type: transferDataSchema,
+      required: false,
+    },
+    freeAgentData: {
+      type: freeAgentDataSchema,
+      required: false,
+    }
+  },
+  { timestamps: true }
+);
+
+// Virtual field for like count
+newsSchema.virtual('likeCount').get(function() {
+  return this.likes ? this.likes.length : 0;
+});
+
+// Add index on createdAt for faster sorting
+newsSchema.index({ createdAt: -1 });
+
+// Ensure virtual fields are serialized
+newsSchema.set('toJSON', { virtuals: true });
+newsSchema.set('toObject', { virtuals: true });
+
+// Create the model
+const News = mongoose.model<INews>('News', newsSchema);
+
+export default News;

package/src/models/notification.ts

@@ -0,0 +1,80 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface INotification extends Document {
+  id: string;
+  userId: mongoose.Types.ObjectId; // Recipient of the notification
+  type: 'transfer_request' | 'transfer_approved' | 'transfer_rejected' | 'transfer_cancelled' | 'player_association_request' | 'player_association_approved' | 'player_association_rejected' | 'system';
+  title: string;
+  message: string;
+  data?: any; // Additional data for the notification
+  isRead: boolean;
+  createdAt: Date;
+  readAt?: Date;
+  expiresAt?: Date;
+}
+
+const notificationSchema = new Schema<INotification>(
+  {
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      required: true
+    },
+    type: {
+      type: String,
+      enum: ['transfer_request', 'transfer_approved', 'transfer_rejected', 'transfer_cancelled', 'player_association_request', 'player_association_approved', 'player_association_rejected', 'system'],
+      required: true
+    },
+    title: {
+      type: String,
+      required: true,
+      maxlength: 200
+    },
+    message: {
+      type: String,
+      required: true,
+      maxlength: 1000
+    },
+    data: {
+      type: Schema.Types.Mixed,
+      default: {}
+    },
+    isRead: {
+      type: Boolean,
+      default: false
+    },
+    createdAt: {
+      type: Date,
+      default: Date.now
+    },
+    readAt: {
+      type: Date
+    },
+    expiresAt: {
+      type: Date
+    }
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    id: true
+  }
+);
+
+// Indexes for efficient querying
+notificationSchema.index({ userId: 1, isRead: 1 });
+notificationSchema.index({ userId: 1, createdAt: -1 });
+notificationSchema.index({ type: 1 });
+notificationSchema.index({ expiresAt: 1 });
+
+// Virtual for populated user details
+notificationSchema.virtual('user', {
+  ref: 'User',
+  localField: 'userId',
+  foreignField: '_id',
+  justOne: true
+});
+
+const Notification = mongoose.model<INotification>('Notification', notificationSchema);
+
+export default Notification;