pro-clubs-shared-dtos 3.0.0

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

@@ -0,0 +1,10 @@
+export type PopulatedPlayerWithTeam = {
+  id: string;
+  name: string;
+  imgUrl?: string;
+  team: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  };
+};

package/src/models/player/player.ts

@@ -0,0 +1,174 @@
+import mongoose, { Schema, Document } from "mongoose";
+import { PopulatedPlayerWithTeam } from "./player-types";
+import { ACHIEVEMENT_TYPE } from "../season-achievement";
+
+export interface IPlayerStats {
+  games: number;
+  goals: number;
+  assists: number;
+  cleanSheets: number;
+  playerOfTheMatch: number;
+  avgRating: number;
+}
+
+export interface IPlayerSeason {
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  team: mongoose.Types.ObjectId;
+  stats: IPlayerStats;
+}
+
+export interface ITransferHistoryEntry {
+  fromTeam: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  } | null; // null for free agent
+  toTeam: {
+    id: string;
+    name: string;
+    imgUrl?: string;
+  } | null; // null when player becomes free agent
+  transferDate: Date;
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+}
+
+export interface IPlayerAchievementHistoryEntry {
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  leagueName: string;
+  achievementType: ACHIEVEMENT_TYPE;
+  rank?: number; // 1st, 2nd, 3rd for rankings
+  teamId: mongoose.Types.ObjectId;
+  teamName: string;
+  stats: {
+    goals?: number;
+    assists?: number;
+    cleanSheets?: number;
+    avgRating?: number;
+    games?: number;
+    playerOfTheMatch?: number;
+  };
+  description?: string;
+  achievedDate: Date;
+}
+
+export interface IPlayer extends Document {
+  id: string;
+  team: mongoose.Types.ObjectId | null;
+  phone?: string;
+  email?: string;
+  name: string;
+  gamertag?: string; // EA gamer tag / player username
+  age: number;
+  imgUrl?: string;
+  position: string;
+  playablePositions: string[];
+  currentSeason?: IPlayerSeason;
+  seasonsHistory: IPlayerSeason[];
+  transferHistory: ITransferHistoryEntry[];
+  achievementHistory: IPlayerAchievementHistoryEntry[];
+}
+
+const playerStatsSchema = new Schema(
+  {
+    games: { type: Number, default: 0, required: true },
+    goals: { type: Number, default: 0, required: true },
+    assists: { type: Number, default: 0, required: true },
+    cleanSheets: { type: Number, default: 0, required: true },
+    playerOfTheMatch: { type: Number, default: 0, required: true },
+    avgRating: { type: Number, default: 0.0, required: true },
+  },
+  { _id: false }
+); // Disable _id for this subdocument
+
+const playerSeasonStatsSchema = new Schema(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Types.ObjectId, ref: "League", required: true },
+    team: { type: mongoose.Types.ObjectId, ref: "Team", required: true },
+    stats: { type: playerStatsSchema },
+  },
+  { _id: false }
+);
+
+const transferHistorySchema = new Schema(
+  {
+    fromTeam: {
+      type: {
+        id: { type: String, required: true },
+        name: { type: String, required: true },
+        imgUrl: { type: String }
+      },
+      required: false,
+      default: null
+    },
+    toTeam: {
+      type: {
+        id: { type: String, required: true },
+        name: { type: String, required: true },
+        imgUrl: { type: String }
+      },
+      required: false,
+      default: null
+    },
+    transferDate: { type: Date, required: true, default: Date.now },
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Types.ObjectId, ref: "League", required: true }
+  },
+  { _id: false }
+);
+
+const playerAchievementHistorySchema = new Schema(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Types.ObjectId, ref: "League", required: true },
+    leagueName: { type: String, required: true },
+    achievementType: { type: String, enum: Object.values(ACHIEVEMENT_TYPE), required: true },
+    rank: { type: Number, required: false },
+    teamId: { type: mongoose.Types.ObjectId, ref: "Team", required: true },
+    teamName: { type: String, required: true },
+    stats: {
+      goals: { type: Number, required: false },
+      assists: { type: Number, required: false },
+      cleanSheets: { type: Number, required: false },
+      avgRating: { type: Number, required: false },
+      games: { type: Number, required: false },
+      playerOfTheMatch: { type: Number, required: false },
+    },
+    description: { type: String, required: false },
+    achievedDate: { type: Date, required: true, default: Date.now },
+  },
+  { _id: false }
+);
+
+const playerSchema: Schema = new Schema(
+  {
+    team: { type: mongoose.Schema.Types.ObjectId, ref: "Team" },
+      email: { type: String },
+      // Reference to the owning user (if this player was created for a user account)
+      userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    phone: { type: String },
+    name: { type: String, required: true },
+    gamertag: { type: String }, // EA gamer tag / player username
+    age: { type: Number, required: true },
+    position: { type: String, required: true },
+    playablePositions: [{ type: String, required: true }],
+    imgUrl: { type: String },
+    currentSeason: playerSeasonStatsSchema,
+    seasonsHistory: [playerSeasonStatsSchema],
+    transferHistory: [transferHistorySchema],
+    achievementHistory: [playerAchievementHistorySchema],
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true, // Use 'id' instead of '_id'
+  }
+);
+
+const Player = mongoose.model<IPlayer>("Player", playerSchema);
+
+export { PopulatedPlayerWithTeam };
+
+export default Player;

package/src/models/player-association-request.ts

@@ -0,0 +1,76 @@
+import mongoose, { Schema, Document } from "mongoose";
+
+export interface IPlayerAssociationRequest extends Document {
+  id: string;
+  userId: mongoose.Types.ObjectId;
+  playerId: mongoose.Types.ObjectId;
+  playerEmail?: string;
+  status: 'pending' | 'approved' | 'rejected';
+  requestedAt: Date;
+  processedAt?: Date;
+  processedBy?: mongoose.Types.ObjectId; // Admin who processed the request
+  reason?: string; // Reason for rejection
+  userMessage?: string; // Message from user explaining why they want this player
+}
+
+const playerAssociationRequestSchema: Schema<IPlayerAssociationRequest> = new Schema<IPlayerAssociationRequest>(
+  {
+    userId: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "User", 
+      required: true 
+    },
+    playerId: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "Player", 
+      required: true 
+    },
+    playerEmail: { 
+      type: String 
+    },
+    status: { 
+      type: String, 
+      enum: ['pending', 'approved', 'rejected'], 
+      default: 'pending' 
+    },
+    requestedAt: { 
+      type: Date, 
+      default: Date.now 
+    },
+    processedAt: { 
+      type: Date 
+    },
+    processedBy: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "User" 
+    },
+    reason: { 
+      type: String 
+    },
+    userMessage: { 
+      type: String 
+    }
+  },
+  {
+    timestamps: true,
+    toJSON: { 
+      virtuals: true,
+      transform: function(doc, ret) {
+        return ret;
+      }
+    },
+    id: true,
+  }
+);
+
+// Index for performance
+playerAssociationRequestSchema.index({ userId: 1 });
+playerAssociationRequestSchema.index({ playerId: 1 });
+playerAssociationRequestSchema.index({ status: 1 });
+
+// Compound index to prevent duplicate pending requests
+playerAssociationRequestSchema.index({ userId: 1, playerId: 1, status: 1 }, { unique: true });
+
+const PlayerAssociationRequest = mongoose.model<IPlayerAssociationRequest>("PlayerAssociationRequest", playerAssociationRequestSchema);
+
+export default PlayerAssociationRequest;

package/src/models/prediction/prediction.ts

@@ -0,0 +1,54 @@
+import { Schema, model, Types, Document } from "mongoose";
+
+export enum PREDICTION_OUTCOME {
+  HOME_WIN = "HOME_WIN",
+  AWAY_WIN = "AWAY_WIN", 
+  DRAW = "DRAW"
+}
+
+export interface IPrediction extends Document {
+  _id: Types.ObjectId;
+  gameId: Types.ObjectId;
+  userId: Types.ObjectId;
+  predictedOutcome: PREDICTION_OUTCOME;
+  confidence?: number; // 1-5 scale, optional
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const predictionSchema = new Schema<IPrediction>({
+  gameId: {
+    type: Schema.Types.ObjectId,
+    ref: "Game",
+    required: true,
+    index: true
+  },
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+    index: true
+  },
+  predictedOutcome: {
+    type: String,
+    enum: Object.values(PREDICTION_OUTCOME),
+    required: true
+  },
+  confidence: {
+    type: Number,
+    min: 1,
+    max: 5,
+    default: 3
+  }
+}, {
+  timestamps: true,
+  collection: "predictions"
+});
+
+// Compound index to ensure one prediction per user per game
+predictionSchema.index({ gameId: 1, userId: 1 }, { unique: true });
+
+// Index for efficient querying by game
+predictionSchema.index({ gameId: 1, createdAt: -1 });
+
+export const Prediction = model<IPrediction>("Prediction", predictionSchema);

package/src/models/season-achievement.ts

@@ -0,0 +1,173 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export enum ACHIEVEMENT_TYPE {
+  CHAMPIONSHIP_WINNER = "Championship Winner",
+  FINALIST = "Finalist", 
+  THIRD_PLACE = "Third Place",
+  TOP_SCORER = "Top Scorer",
+  TOP_ASSIST_PROVIDER = "Top Assist Provider",
+  BEST_GOALKEEPER = "Best Goalkeeper",
+  BEST_CENTER_BACK = "Best Center Back",
+  BEST_DEFENSIVE_MIDFIELDER = "Best Defensive Midfielder",
+  BEST_MIDFIELDER = "Best Midfielder",
+  BEST_ATTACKING_MIDFIELDER = "Best Attacking Midfielder",
+  BEST_WINGER = "Best Winger",
+  BEST_STRIKER = "Best Striker",
+  MOST_CLEAN_SHEETS = "Most Clean Sheets",
+  PLAYER_OF_THE_SEASON = "Player of the Season",
+  TEAM_OF_THE_SEASON = "Team of the Season"
+}
+
+export interface IPlayerAchievement {
+  playerId: mongoose.Types.ObjectId;
+  playerName: string;
+  playerImgUrl?: string;
+  teamId: mongoose.Types.ObjectId;
+  teamName: string;
+  teamImgUrl?: string;
+  achievementType: ACHIEVEMENT_TYPE;
+  rank?: number; // 1st, 2nd, 3rd for top scorers/assists
+  seasonNumber?: number; // Season when achievement was earned
+  stats: {
+    goals?: number;
+    assists?: number;
+    cleanSheets?: number;
+    avgRating?: number;
+    games?: number;
+    playerOfTheMatch?: number;
+  };
+  description?: string; // Additional context about the achievement
+}
+
+export interface ITeamAchievement {
+  teamId: mongoose.Types.ObjectId;
+  teamName: string;
+  teamImgUrl?: string;
+  achievementType: ACHIEVEMENT_TYPE;
+  rank?: number; // Final position
+  seasonNumber?: number; // Season when achievement was earned
+  stats: {
+    wins?: number;
+    losses?: number;
+    draws?: number;
+    goalsScored?: number;
+    goalsConceded?: number;
+    points?: number;
+    goalDifference?: number;
+  };
+  description?: string;
+}
+
+export interface ISeasonAchievements extends Document {
+  id: string;
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  leagueName: string;
+  startDate: Date;
+  endDate: Date;
+  playerAchievements: IPlayerAchievement[];
+  teamAchievements: ITeamAchievement[];
+  champion: {
+    teamId: mongoose.Types.ObjectId;
+    teamName: string;
+    teamImgUrl?: string;
+  };
+  finalist?: {
+    teamId: mongoose.Types.ObjectId;
+    teamName: string;
+    teamImgUrl?: string;
+  };
+  thirdPlace?: {
+    teamId: mongoose.Types.ObjectId;
+    teamName: string;
+    teamImgUrl?: string;
+  };
+  createdAt: Date;
+  createdBy: mongoose.Types.ObjectId; // Admin who ended the season
+}
+
+const playerAchievementSchema = new Schema<IPlayerAchievement>(
+  {
+    playerId: { type: mongoose.Schema.Types.ObjectId, ref: 'Player', required: true },
+    playerName: { type: String, required: true },
+    playerImgUrl: { type: String, required: false },
+    teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: true },
+    teamName: { type: String, required: true },
+    teamImgUrl: { type: String, required: false },
+    achievementType: { type: String, enum: Object.values(ACHIEVEMENT_TYPE), required: true },
+    rank: { type: Number, required: false },
+    seasonNumber: { type: Number, required: false },
+    stats: {
+      goals: { type: Number, required: false },
+      assists: { type: Number, required: false },
+      cleanSheets: { type: Number, required: false },
+      avgRating: { type: Number, required: false },
+      games: { type: Number, required: false },
+      playerOfTheMatch: { type: Number, required: false },
+    },
+    description: { type: String, required: false },
+  },
+  { _id: false }
+);
+
+const teamAchievementSchema = new Schema<ITeamAchievement>(
+  {
+    teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: true },
+    teamName: { type: String, required: true },
+    teamImgUrl: { type: String, required: false },
+    achievementType: { type: String, enum: Object.values(ACHIEVEMENT_TYPE), required: true },
+    rank: { type: Number, required: false },
+    seasonNumber: { type: Number, required: false },
+    stats: {
+      wins: { type: Number, required: false },
+      losses: { type: Number, required: false },
+      draws: { type: Number, required: false },
+      goalsScored: { type: Number, required: false },
+      goalsConceded: { type: Number, required: false },
+      points: { type: Number, required: false },
+      goalDifference: { type: Number, required: false },
+    },
+    description: { type: String, required: false },
+  },
+  { _id: false }
+);
+
+const seasonAchievementsSchema = new Schema<ISeasonAchievements>(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: 'League', required: true },
+    leagueName: { type: String, required: true },
+    startDate: { type: Date, required: true },
+    endDate: { type: Date, required: true },
+    playerAchievements: [playerAchievementSchema],
+    teamAchievements: [teamAchievementSchema],
+    champion: {
+      teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: true },
+      teamName: { type: String, required: true },
+      teamImgUrl: { type: String, required: false },
+    },
+    finalist: {
+      teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: false },
+      teamName: { type: String, required: false },
+      teamImgUrl: { type: String, required: false },
+    },
+    thirdPlace: {
+      teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: false },
+      teamName: { type: String, required: false },
+      teamImgUrl: { type: String, required: false },
+    },
+    createdAt: { type: Date, default: Date.now },
+    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true,
+  }
+);
+
+// Create compound index for efficient queries
+seasonAchievementsSchema.index({ league: 1, seasonNumber: 1 }, { unique: true });
+
+const SeasonAchievements = mongoose.model<ISeasonAchievements>("SeasonAchievements", seasonAchievementsSchema);
+
+export default SeasonAchievements;

package/src/models/team-of-the-season.ts

@@ -0,0 +1,74 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface ITeamOfTheSeasonPlayer {
+  playerId: mongoose.Types.ObjectId;
+  playerName: string;
+  playerImgUrl?: string;
+  position: string;
+  teamId: mongoose.Types.ObjectId;
+  teamName: string;
+  teamImgUrl?: string;
+  stats: {
+    games: number;
+    goals: number;
+    assists: number;
+    cleanSheets: number;
+    avgRating: number;
+    playerOfTheMatch: number;
+    score: number; // Calculated TOTS score
+  };
+}
+
+export interface ITeamOfTheSeason extends Document {
+  id: string;
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  formation: string; // e.g., "3-5-2", "4-3-3"
+  players: ITeamOfTheSeasonPlayer[];
+  createdAt: Date;
+  generatedBy: string;
+}
+
+const teamOfTheSeasonPlayerSchema = new Schema<ITeamOfTheSeasonPlayer>(
+  {
+    playerId: { type: mongoose.Schema.Types.ObjectId, ref: 'Player', required: true },
+    playerName: { type: String, required: true },
+    playerImgUrl: { type: String, required: false },
+    position: { type: String, required: true },
+    teamId: { type: mongoose.Schema.Types.ObjectId, ref: 'Team', required: true },
+    teamName: { type: String, required: true },
+    teamImgUrl: { type: String, required: false },
+    stats: {
+      games: { type: Number, required: true },
+      goals: { type: Number, required: true },
+      assists: { type: Number, required: true },
+      cleanSheets: { type: Number, required: true },
+      avgRating: { type: Number, required: true },
+      playerOfTheMatch: { type: Number, required: true },
+      score: { type: Number, required: true },
+    },
+  },
+  { _id: false }
+);
+
+const teamOfTheSeasonSchema = new Schema<ITeamOfTheSeason>(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: 'League', required: true },
+    formation: { type: String, required: true },
+    players: [teamOfTheSeasonPlayerSchema],
+    createdAt: { type: Date, default: Date.now },
+    generatedBy: { type: String, required: true },
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true,
+  }
+);
+
+// Create compound index for unique TOTS per season/league/formation
+teamOfTheSeasonSchema.index({ seasonNumber: 1, league: 1, formation: 1 }, { unique: true });
+
+const TeamOfTheSeason = mongoose.model<ITeamOfTheSeason>('TeamOfTheSeason', teamOfTheSeasonSchema);
+
+export default TeamOfTheSeason;

package/src/models/team.ts

@@ -0,0 +1,133 @@
+import mongoose, { Schema, Document } from "mongoose";
+import { IPlayer } from "./player/player";
+import { ACHIEVEMENT_TYPE } from "./season-achievement";
+
+export type TeamWithPlayers = {
+  id: string;
+  name: string;
+  league: mongoose.Types.ObjectId;
+  imgUrl?: string;
+  players: IPlayer[];
+  captain?: mongoose.Types.ObjectId;
+  viceCaptain?: mongoose.Types.ObjectId;
+  seasonsHistory: ITeamSeason[];
+  currentSeason?: ITeamSeason;
+};
+
+export interface ITeamStats {
+  wins: number;
+  losses: number;
+  draws: number;
+  goalsScored: number;
+  goalsConceded: number;
+  cleanSheets: number;
+}
+
+export interface ITeamSeason {
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  stats: ITeamStats;
+  finalPosition?: number; // Final league position for completed seasons
+}
+
+export interface ITeamAchievementHistoryEntry {
+  seasonNumber: number;
+  league: mongoose.Types.ObjectId;
+  leagueName: string;
+  achievementType: ACHIEVEMENT_TYPE;
+  rank?: number; // Final position or ranking
+  stats: {
+    wins?: number;
+    losses?: number;
+    draws?: number;
+    goalsScored?: number;
+    goalsConceded?: number;
+    points?: number;
+    goalDifference?: number;
+  };
+  description?: string;
+  achievedDate: Date;
+}
+
+export interface ITeam extends Document {
+  id: string;
+  name: string;
+  eaTeamId?: string; // EA Team ID from API
+  clubsTeamName?: string; // EA Clubs Team Name from API
+  imgUrl?: string;
+  league: mongoose.Types.ObjectId | null;
+  players: mongoose.Types.ObjectId[];
+  captain: mongoose.Types.ObjectId;
+  viceCaptain?: mongoose.Types.ObjectId;
+  seasonsHistory: ITeamSeason[];
+  currentSeason?: ITeamSeason;
+  achievementHistory: ITeamAchievementHistoryEntry[];
+}
+
+const teamStatsSchema = new Schema<ITeamStats>(
+  {
+    wins: { type: Number, default: 0 },
+    losses: { type: Number, default: 0 },
+    draws: { type: Number, default: 0 },
+    goalsScored: { type: Number, default: 0 },
+    goalsConceded: { type: Number, default: 0 },
+    cleanSheets: { type: Number, default: 0 },
+  },
+  { _id: false }
+);
+
+const teamSeasonSchema = new Schema<ITeamSeason>(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League" },
+    stats: teamStatsSchema,
+    finalPosition: { type: Number, required: false },
+  },
+  { _id: false }
+);
+
+const teamAchievementHistorySchema = new Schema<ITeamAchievementHistoryEntry>(
+  {
+    seasonNumber: { type: Number, required: true },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League", required: true },
+    leagueName: { type: String, required: true },
+    achievementType: { type: String, enum: Object.values(ACHIEVEMENT_TYPE), required: true },
+    rank: { type: Number, required: false },
+    stats: {
+      wins: { type: Number, required: false },
+      losses: { type: Number, required: false },
+      draws: { type: Number, required: false },
+      goalsScored: { type: Number, required: false },
+      goalsConceded: { type: Number, required: false },
+      points: { type: Number, required: false },
+      goalDifference: { type: Number, required: false },
+    },
+    description: { type: String, required: false },
+    achievedDate: { type: Date, required: true, default: Date.now },
+  },
+  { _id: false }
+);
+
+const teamSchema: Schema<ITeam> = new Schema<ITeam>(
+  {
+    name: { type: String, required: true, unique: true },
+    eaTeamId: { type: String }, // EA Team ID from API
+    clubsTeamName: { type: String }, // EA Clubs Team Name from API
+    imgUrl: { type: String },
+    league: { type: mongoose.Schema.Types.ObjectId, ref: "League" },
+    players: [{ type: mongoose.Schema.Types.ObjectId, ref: "Player" }],
+    captain: { type: mongoose.Schema.Types.ObjectId, ref: "Player" },
+    viceCaptain: { type: mongoose.Schema.Types.ObjectId, ref: "Player" },
+    seasonsHistory: [teamSeasonSchema],
+    currentSeason: teamSeasonSchema,
+    achievementHistory: [teamAchievementHistorySchema],
+  },
+  {
+    toJSON: { virtuals: true },
+    id: true, // Use 'id' instead of '_id'
+  }
+);
+
+const Team = mongoose.model<ITeam>("Team", teamSchema);
+
+export default Team;