Updated via schema editor on 2025-09-02 19:34

backend/src/db/api/games.js

@@ -37,6 +37,10 @@ module.exports = class GamesDBApi {
       transaction,
     });
 
+    await games.setSeason(data.season || null, {
+      transaction,
+    });
+
     return games;
   }
 
@@ -110,6 +114,14 @@ module.exports = class GamesDBApi {
       );
     }
 
+    if (data.season !== undefined) {
+      await games.setSeason(
+        data.season,
+
+        { transaction },
+      );
+    }
+
     return games;
   }
 
@@ -171,6 +183,10 @@ module.exports = class GamesDBApi {
 
     const output = games.get({ plain: true });
 
+    output.player_game_scores_game = await games.getPlayer_game_scores_game({
+      transaction,
+    });
+
     output.league = await games.getLeague({
       transaction,
     });
@@ -183,6 +199,10 @@ module.exports = class GamesDBApi {
       transaction,
     });
 
+    output.season = await games.getSeason({
+      transaction,
+    });
+
     return output;
   }
 
@@ -243,6 +263,32 @@ module.exports = class GamesDBApi {
         model: db.leagues,
         as: 'leagues',
       },
+
+      {
+        model: db.seasons,
+        as: 'season',
+
+        where: filter.season
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.season
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.season
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
     ];
 
     if (filter) {

backend/src/db/api/leagues.js

@@ -16,6 +16,7 @@ module.exports = class LeaguesDBApi {
         id: data.id || undefined,
 
         name: data.name || null,
+        handicapformula: data.handicapformula || null,
         importHash: data.importHash || null,
         createdById: currentUser.id,
         updatedById: currentUser.id,
@@ -35,6 +36,7 @@ module.exports = class LeaguesDBApi {
       id: item.id || undefined,
 
       name: item.name || null,
+      handicapformula: item.handicapformula || null,
       importHash: item.importHash || null,
       createdById: currentUser.id,
       updatedById: currentUser.id,
@@ -60,6 +62,9 @@ module.exports = class LeaguesDBApi {
 
     if (data.name !== undefined) updatePayload.name = data.name;
 
+    if (data.handicapformula !== undefined)
+      updatePayload.handicapformula = data.handicapformula;
+
     updatePayload.updatedById = currentUser.id;
 
     await leagues.update(updatePayload, { transaction });
@@ -149,6 +154,29 @@ module.exports = class LeaguesDBApi {
       transaction,
     });
 
+    output.seasons_leagues = await leagues.getSeasons_leagues({
+      transaction,
+    });
+
+    output.seasons_league = await leagues.getSeasons_league({
+      transaction,
+    });
+
+    output.player_game_scores_leagues =
+      await leagues.getPlayer_game_scores_leagues({
+        transaction,
+      });
+
+    output.player_season_stats_leagues =
+      await leagues.getPlayer_season_stats_leagues({
+        transaction,
+      });
+
+    output.team_season_stats_leagues =
+      await leagues.getTeam_season_stats_leagues({
+        transaction,
+      });
+
     return output;
   }
 
@@ -190,6 +218,17 @@ module.exports = class LeaguesDBApi {
         };
       }
 
+      if (filter.handicapformula) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'leagues',
+            'handicapformula',
+            filter.handicapformula,
+          ),
+        };
+      }
+
       if (filter.active !== undefined) {
         where = {
           ...where,

backend/src/db/api/player_game_scores.js

@@ -0,0 +1,432 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class Player_game_scoresDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_game_scores = await db.player_game_scores.create(
+      {
+        id: data.id || undefined,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await player_game_scores.setLeagues(data.leagues || null, {
+      transaction,
+    });
+
+    await player_game_scores.setGame(data.game || null, {
+      transaction,
+    });
+
+    await player_game_scores.setPlayer(data.player || null, {
+      transaction,
+    });
+
+    await player_game_scores.setTeam(data.team || null, {
+      transaction,
+    });
+
+    return player_game_scores;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const player_game_scoresData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const player_game_scores = await db.player_game_scores.bulkCreate(
+      player_game_scoresData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return player_game_scores;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const player_game_scores = await db.player_game_scores.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    updatePayload.updatedById = currentUser.id;
+
+    await player_game_scores.update(updatePayload, { transaction });
+
+    if (data.leagues !== undefined) {
+      await player_game_scores.setLeagues(
+        data.leagues,
+
+        { transaction },
+      );
+    }
+
+    if (data.game !== undefined) {
+      await player_game_scores.setGame(
+        data.game,
+
+        { transaction },
+      );
+    }
+
+    if (data.player !== undefined) {
+      await player_game_scores.setPlayer(
+        data.player,
+
+        { transaction },
+      );
+    }
+
+    if (data.team !== undefined) {
+      await player_game_scores.setTeam(
+        data.team,
+
+        { transaction },
+      );
+    }
+
+    return player_game_scores;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_game_scores = await db.player_game_scores.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of player_game_scores) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of player_game_scores) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return player_game_scores;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_game_scores = await db.player_game_scores.findByPk(
+      id,
+      options,
+    );
+
+    await player_game_scores.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await player_game_scores.destroy({
+      transaction,
+    });
+
+    return player_game_scores;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_game_scores = await db.player_game_scores.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!player_game_scores) {
+      return player_game_scores;
+    }
+
+    const output = player_game_scores.get({ plain: true });
+
+    output.leagues = await player_game_scores.getLeagues({
+      transaction,
+    });
+
+    output.game = await player_game_scores.getGame({
+      transaction,
+    });
+
+    output.player = await player_game_scores.getPlayer({
+      transaction,
+    });
+
+    output.team = await player_game_scores.getTeam({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userLeagues = (user && user.leagues?.id) || null;
+
+    if (userLeagues) {
+      if (options?.currentUser?.leaguesId) {
+        where.leaguesId = options.currentUser.leaguesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.leagues,
+        as: 'leagues',
+      },
+
+      {
+        model: db.games,
+        as: 'game',
+
+        where: filter.game
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.game
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  date: {
+                    [Op.or]: filter.game
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.players,
+        as: 'player',
+
+        where: filter.player
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.player
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  first_name: {
+                    [Op.or]: filter.player
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.teams,
+        as: 'team',
+
+        where: filter.team
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.team
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.team
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.leagues) {
+        const listItems = filter.leagues.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          leaguesId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.leaguesId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.player_game_scores.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('player_game_scores', 'id', query),
+        ],
+      };
+    }
+
+    const records = await db.player_game_scores.findAll({
+      attributes: ['id', 'id'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['id', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.id,
+    }));
+  }
+};

backend/src/db/api/player_season_stats.js

@@ -0,0 +1,535 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class Player_season_statsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_season_stats = await db.player_season_stats.create(
+      {
+        id: data.id || undefined,
+
+        totalpoints: data.totalpoints || null,
+        gamesplayed: data.gamesplayed || null,
+        eightballruns: data.eightballruns || null,
+        eightballbreaks: data.eightballbreaks || null,
+        nineballruns: data.nineballruns || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await player_season_stats.setLeagues(data.leagues || null, {
+      transaction,
+    });
+
+    await player_season_stats.setPlayer(data.player || null, {
+      transaction,
+    });
+
+    await player_season_stats.setSeason(data.season || null, {
+      transaction,
+    });
+
+    return player_season_stats;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const player_season_statsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      totalpoints: item.totalpoints || null,
+      gamesplayed: item.gamesplayed || null,
+      eightballruns: item.eightballruns || null,
+      eightballbreaks: item.eightballbreaks || null,
+      nineballruns: item.nineballruns || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const player_season_stats = await db.player_season_stats.bulkCreate(
+      player_season_statsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return player_season_stats;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const player_season_stats = await db.player_season_stats.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.totalpoints !== undefined)
+      updatePayload.totalpoints = data.totalpoints;
+
+    if (data.gamesplayed !== undefined)
+      updatePayload.gamesplayed = data.gamesplayed;
+
+    if (data.eightballruns !== undefined)
+      updatePayload.eightballruns = data.eightballruns;
+
+    if (data.eightballbreaks !== undefined)
+      updatePayload.eightballbreaks = data.eightballbreaks;
+
+    if (data.nineballruns !== undefined)
+      updatePayload.nineballruns = data.nineballruns;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await player_season_stats.update(updatePayload, { transaction });
+
+    if (data.leagues !== undefined) {
+      await player_season_stats.setLeagues(
+        data.leagues,
+
+        { transaction },
+      );
+    }
+
+    if (data.player !== undefined) {
+      await player_season_stats.setPlayer(
+        data.player,
+
+        { transaction },
+      );
+    }
+
+    if (data.season !== undefined) {
+      await player_season_stats.setSeason(
+        data.season,
+
+        { transaction },
+      );
+    }
+
+    return player_season_stats;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_season_stats = await db.player_season_stats.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of player_season_stats) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of player_season_stats) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return player_season_stats;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_season_stats = await db.player_season_stats.findByPk(
+      id,
+      options,
+    );
+
+    await player_season_stats.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await player_season_stats.destroy({
+      transaction,
+    });
+
+    return player_season_stats;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const player_season_stats = await db.player_season_stats.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!player_season_stats) {
+      return player_season_stats;
+    }
+
+    const output = player_season_stats.get({ plain: true });
+
+    output.leagues = await player_season_stats.getLeagues({
+      transaction,
+    });
+
+    output.player = await player_season_stats.getPlayer({
+      transaction,
+    });
+
+    output.season = await player_season_stats.getSeason({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userLeagues = (user && user.leagues?.id) || null;
+
+    if (userLeagues) {
+      if (options?.currentUser?.leaguesId) {
+        where.leaguesId = options.currentUser.leaguesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.leagues,
+        as: 'leagues',
+      },
+
+      {
+        model: db.players,
+        as: 'player',
+
+        where: filter.player
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.player
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  first_name: {
+                    [Op.or]: filter.player
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.seasons,
+        as: 'season',
+
+        where: filter.season
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.season
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.season
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.totalpointsRange) {
+        const [start, end] = filter.totalpointsRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            totalpoints: {
+              ...where.totalpoints,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            totalpoints: {
+              ...where.totalpoints,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.gamesplayedRange) {
+        const [start, end] = filter.gamesplayedRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            gamesplayed: {
+              ...where.gamesplayed,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            gamesplayed: {
+              ...where.gamesplayed,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.eightballrunsRange) {
+        const [start, end] = filter.eightballrunsRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            eightballruns: {
+              ...where.eightballruns,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            eightballruns: {
+              ...where.eightballruns,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.eightballbreaksRange) {
+        const [start, end] = filter.eightballbreaksRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            eightballbreaks: {
+              ...where.eightballbreaks,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            eightballbreaks: {
+              ...where.eightballbreaks,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.nineballrunsRange) {
+        const [start, end] = filter.nineballrunsRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            nineballruns: {
+              ...where.nineballruns,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            nineballruns: {
+              ...where.nineballruns,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.leagues) {
+        const listItems = filter.leagues.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          leaguesId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.leaguesId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.player_season_stats.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('player_season_stats', 'gamesplayed', query),
+        ],
+      };
+    }
+
+    const records = await db.player_season_stats.findAll({
+      attributes: ['id', 'gamesplayed'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['gamesplayed', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.gamesplayed,
+    }));
+  }
+};

backend/src/db/api/players.js

@@ -164,6 +164,16 @@ module.exports = class PlayersDBApi {
 
     const output = players.get({ plain: true });
 
+    output.player_game_scores_player =
+      await players.getPlayer_game_scores_player({
+        transaction,
+      });
+
+    output.player_season_stats_player =
+      await players.getPlayer_season_stats_player({
+        transaction,
+      });
+
     output.team = await players.getTeam({
       transaction,
     });

backend/src/db/api/seasons.js

@@ -0,0 +1,405 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class SeasonsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const seasons = await db.seasons.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        startdate: data.startdate || null,
+        enddate: data.enddate || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await seasons.setLeagues(data.leagues || null, {
+      transaction,
+    });
+
+    await seasons.setLeague(data.league || null, {
+      transaction,
+    });
+
+    return seasons;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const seasonsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      startdate: item.startdate || null,
+      enddate: item.enddate || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const seasons = await db.seasons.bulkCreate(seasonsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return seasons;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const seasons = await db.seasons.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.startdate !== undefined) updatePayload.startdate = data.startdate;
+
+    if (data.enddate !== undefined) updatePayload.enddate = data.enddate;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await seasons.update(updatePayload, { transaction });
+
+    if (data.leagues !== undefined) {
+      await seasons.setLeagues(
+        data.leagues,
+
+        { transaction },
+      );
+    }
+
+    if (data.league !== undefined) {
+      await seasons.setLeague(
+        data.league,
+
+        { transaction },
+      );
+    }
+
+    return seasons;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const seasons = await db.seasons.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of seasons) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of seasons) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return seasons;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const seasons = await db.seasons.findByPk(id, options);
+
+    await seasons.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await seasons.destroy({
+      transaction,
+    });
+
+    return seasons;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const seasons = await db.seasons.findOne({ where }, { transaction });
+
+    if (!seasons) {
+      return seasons;
+    }
+
+    const output = seasons.get({ plain: true });
+
+    output.games_season = await seasons.getGames_season({
+      transaction,
+    });
+
+    output.player_season_stats_season =
+      await seasons.getPlayer_season_stats_season({
+        transaction,
+      });
+
+    output.team_season_stats_season = await seasons.getTeam_season_stats_season(
+      {
+        transaction,
+      },
+    );
+
+    output.leagues = await seasons.getLeagues({
+      transaction,
+    });
+
+    output.league = await seasons.getLeague({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userLeagues = (user && user.leagues?.id) || null;
+
+    if (userLeagues) {
+      if (options?.currentUser?.leaguesId) {
+        where.leaguesId = options.currentUser.leaguesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.leagues,
+        as: 'leagues',
+      },
+
+      {
+        model: db.leagues,
+        as: 'league',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('seasons', 'name', filter.name),
+        };
+      }
+
+      if (filter.startdateRange) {
+        const [start, end] = filter.startdateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            startdate: {
+              ...where.startdate,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            startdate: {
+              ...where.startdate,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.enddateRange) {
+        const [start, end] = filter.enddateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            enddate: {
+              ...where.enddate,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            enddate: {
+              ...where.enddate,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.leagues) {
+        const listItems = filter.leagues.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          leaguesId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.league) {
+        const listItems = filter.league.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          leagueId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.leaguesId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.seasons.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('seasons', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.seasons.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};

backend/src/db/api/team_season_stats.js

@@ -0,0 +1,387 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class Team_season_statsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const team_season_stats = await db.team_season_stats.create(
+      {
+        id: data.id || undefined,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await team_season_stats.setLeagues(data.leagues || null, {
+      transaction,
+    });
+
+    await team_season_stats.setTeam(data.team || null, {
+      transaction,
+    });
+
+    await team_season_stats.setSeason(data.season || null, {
+      transaction,
+    });
+
+    return team_season_stats;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const team_season_statsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const team_season_stats = await db.team_season_stats.bulkCreate(
+      team_season_statsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return team_season_stats;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const team_season_stats = await db.team_season_stats.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    updatePayload.updatedById = currentUser.id;
+
+    await team_season_stats.update(updatePayload, { transaction });
+
+    if (data.leagues !== undefined) {
+      await team_season_stats.setLeagues(
+        data.leagues,
+
+        { transaction },
+      );
+    }
+
+    if (data.team !== undefined) {
+      await team_season_stats.setTeam(
+        data.team,
+
+        { transaction },
+      );
+    }
+
+    if (data.season !== undefined) {
+      await team_season_stats.setSeason(
+        data.season,
+
+        { transaction },
+      );
+    }
+
+    return team_season_stats;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const team_season_stats = await db.team_season_stats.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of team_season_stats) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of team_season_stats) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return team_season_stats;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const team_season_stats = await db.team_season_stats.findByPk(id, options);
+
+    await team_season_stats.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await team_season_stats.destroy({
+      transaction,
+    });
+
+    return team_season_stats;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const team_season_stats = await db.team_season_stats.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!team_season_stats) {
+      return team_season_stats;
+    }
+
+    const output = team_season_stats.get({ plain: true });
+
+    output.leagues = await team_season_stats.getLeagues({
+      transaction,
+    });
+
+    output.team = await team_season_stats.getTeam({
+      transaction,
+    });
+
+    output.season = await team_season_stats.getSeason({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userLeagues = (user && user.leagues?.id) || null;
+
+    if (userLeagues) {
+      if (options?.currentUser?.leaguesId) {
+        where.leaguesId = options.currentUser.leaguesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.leagues,
+        as: 'leagues',
+      },
+
+      {
+        model: db.teams,
+        as: 'team',
+
+        where: filter.team
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.team
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.team
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.seasons,
+        as: 'season',
+
+        where: filter.season
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.season
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.season
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.leagues) {
+        const listItems = filter.leagues.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          leaguesId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.leaguesId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.team_season_stats.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('team_season_stats', 'id', query),
+        ],
+      };
+    }
+
+    const records = await db.team_season_stats.findAll({
+      attributes: ['id', 'id'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['id', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.id,
+    }));
+  }
+};

backend/src/db/api/teams.js

@@ -177,6 +177,14 @@ module.exports = class TeamsDBApi {
       transaction,
     });
 
+    output.player_game_scores_team = await teams.getPlayer_game_scores_team({
+      transaction,
+    });
+
+    output.team_season_stats_team = await teams.getTeam_season_stats_team({
+      transaction,
+    });
+
     output.league = await teams.getLeague({
       transaction,
     });

backend/src/db/migrations/1756838714724.js

@@ -0,0 +1,90 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.createTable(
+        'seasons',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'seasons',
+        'leaguesId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'leagues',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('seasons', 'leaguesId', {
+        transaction,
+      });
+
+      await queryInterface.dropTable('seasons', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838754108.js

@@ -0,0 +1,47 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'seasons',
+        'name',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('seasons', 'name', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838786759.js

@@ -0,0 +1,49 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'seasons',
+        'startdate',
+        {
+          type: Sequelize.DataTypes.DATEONLY,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('seasons', 'startdate', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838811807.js

@@ -0,0 +1,47 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'seasons',
+        'enddate',
+        {
+          type: Sequelize.DataTypes.DATEONLY,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('seasons', 'enddate', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838843347.js

@@ -0,0 +1,52 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'seasons',
+        'leagueId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'leagues',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('seasons', 'leagueId', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838870227.js

@@ -0,0 +1,52 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'games',
+        'seasonId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'seasons',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('games', 'seasonId', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838906955.js

@@ -0,0 +1,90 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.createTable(
+        'player_game_scores',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'player_game_scores',
+        'leaguesId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'leagues',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_game_scores', 'leaguesId', {
+        transaction,
+      });
+
+      await queryInterface.dropTable('player_game_scores', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838945828.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_game_scores',
+        'gameId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'games',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_game_scores', 'gameId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756838975793.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_game_scores',
+        'playerId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'players',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_game_scores', 'playerId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839010904.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_game_scores',
+        'teamId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'teams',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_game_scores', 'teamId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839033615.js

@@ -0,0 +1,49 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'leagues',
+        'handicapformula',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('leagues', 'handicapformula', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839064708.js

@@ -0,0 +1,90 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.createTable(
+        'player_season_stats',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'leaguesId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'leagues',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'leaguesId', {
+        transaction,
+      });
+
+      await queryInterface.dropTable('player_season_stats', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839091072.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'playerId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'players',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'playerId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839123590.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'seasonId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'seasons',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'seasonId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839155088.js

@@ -0,0 +1,49 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'totalpoints',
+        {
+          type: Sequelize.DataTypes.INTEGER,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'totalpoints', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839183953.js

@@ -0,0 +1,49 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'gamesplayed',
+        {
+          type: Sequelize.DataTypes.INTEGER,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'gamesplayed', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839212457.js

@@ -0,0 +1,51 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'eightballruns',
+        {
+          type: Sequelize.DataTypes.INTEGER,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn(
+        'player_season_stats',
+        'eightballruns',
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839243210.js

@@ -0,0 +1,51 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'eightballbreaks',
+        {
+          type: Sequelize.DataTypes.INTEGER,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn(
+        'player_season_stats',
+        'eightballbreaks',
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839276003.js

@@ -0,0 +1,49 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'player_season_stats',
+        'nineballruns',
+        {
+          type: Sequelize.DataTypes.INTEGER,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('player_season_stats', 'nineballruns', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839309071.js

@@ -0,0 +1,90 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.createTable(
+        'team_season_stats',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'team_season_stats',
+        'leaguesId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'leagues',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('team_season_stats', 'leaguesId', {
+        transaction,
+      });
+
+      await queryInterface.dropTable('team_season_stats', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839330961.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'team_season_stats',
+        'teamId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'teams',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('team_season_stats', 'teamId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839362416.js

@@ -0,0 +1,54 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'team_season_stats',
+        'seasonId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'seasons',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('team_season_stats', 'seasonId', {
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/migrations/1756839362565.js

@@ -0,0 +1,36 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/models/games.js

@@ -42,6 +42,14 @@ module.exports = function (sequelize, DataTypes) {
   games.associate = (db) => {
     /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
 
+    db.games.hasMany(db.player_game_scores, {
+      as: 'player_game_scores_game',
+      foreignKey: {
+        name: 'gameId',
+      },
+      constraints: false,
+    });
+
     //end loop
 
     db.games.belongsTo(db.leagues, {
@@ -68,6 +76,14 @@ module.exports = function (sequelize, DataTypes) {
       constraints: false,
     });
 
+    db.games.belongsTo(db.seasons, {
+      as: 'season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
     db.games.belongsTo(db.users, {
       as: 'createdBy',
     });

backend/src/db/models/leagues.js

@@ -18,6 +18,10 @@ module.exports = function (sequelize, DataTypes) {
         type: DataTypes.TEXT,
       },
 
+      handicapformula: {
+        type: DataTypes.TEXT,
+      },
+
       importHash: {
         type: DataTypes.STRING(255),
         allowNull: true,
@@ -82,6 +86,46 @@ module.exports = function (sequelize, DataTypes) {
       constraints: false,
     });
 
+    db.leagues.hasMany(db.seasons, {
+      as: 'seasons_leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.leagues.hasMany(db.seasons, {
+      as: 'seasons_league',
+      foreignKey: {
+        name: 'leagueId',
+      },
+      constraints: false,
+    });
+
+    db.leagues.hasMany(db.player_game_scores, {
+      as: 'player_game_scores_leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.leagues.hasMany(db.player_season_stats, {
+      as: 'player_season_stats_leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.leagues.hasMany(db.team_season_stats, {
+      as: 'team_season_stats_leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
     //end loop
 
     db.leagues.belongsTo(db.users, {

backend/src/db/models/player_game_scores.js

@@ -0,0 +1,77 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const player_game_scores = sequelize.define(
+    'player_game_scores',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  player_game_scores.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.player_game_scores.belongsTo(db.leagues, {
+      as: 'leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.player_game_scores.belongsTo(db.games, {
+      as: 'game',
+      foreignKey: {
+        name: 'gameId',
+      },
+      constraints: false,
+    });
+
+    db.player_game_scores.belongsTo(db.players, {
+      as: 'player',
+      foreignKey: {
+        name: 'playerId',
+      },
+      constraints: false,
+    });
+
+    db.player_game_scores.belongsTo(db.teams, {
+      as: 'team',
+      foreignKey: {
+        name: 'teamId',
+      },
+      constraints: false,
+    });
+
+    db.player_game_scores.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.player_game_scores.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return player_game_scores;
+};

backend/src/db/models/player_season_stats.js

@@ -0,0 +1,89 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const player_season_stats = sequelize.define(
+    'player_season_stats',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      totalpoints: {
+        type: DataTypes.INTEGER,
+      },
+
+      gamesplayed: {
+        type: DataTypes.INTEGER,
+      },
+
+      eightballruns: {
+        type: DataTypes.INTEGER,
+      },
+
+      eightballbreaks: {
+        type: DataTypes.INTEGER,
+      },
+
+      nineballruns: {
+        type: DataTypes.INTEGER,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  player_season_stats.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.player_season_stats.belongsTo(db.leagues, {
+      as: 'leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.player_season_stats.belongsTo(db.players, {
+      as: 'player',
+      foreignKey: {
+        name: 'playerId',
+      },
+      constraints: false,
+    });
+
+    db.player_season_stats.belongsTo(db.seasons, {
+      as: 'season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
+    db.player_season_stats.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.player_season_stats.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return player_season_stats;
+};

backend/src/db/models/players.js

@@ -46,6 +46,22 @@ module.exports = function (sequelize, DataTypes) {
   players.associate = (db) => {
     /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
 
+    db.players.hasMany(db.player_game_scores, {
+      as: 'player_game_scores_player',
+      foreignKey: {
+        name: 'playerId',
+      },
+      constraints: false,
+    });
+
+    db.players.hasMany(db.player_season_stats, {
+      as: 'player_season_stats_player',
+      foreignKey: {
+        name: 'playerId',
+      },
+      constraints: false,
+    });
+
     //end loop
 
     db.players.belongsTo(db.teams, {

backend/src/db/models/seasons.js

@@ -0,0 +1,109 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const seasons = sequelize.define(
+    'seasons',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      startdate: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('startdate')
+            ? moment.utc(this.getDataValue('startdate')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      enddate: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('enddate')
+            ? moment.utc(this.getDataValue('enddate')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  seasons.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.seasons.hasMany(db.games, {
+      as: 'games_season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
+    db.seasons.hasMany(db.player_season_stats, {
+      as: 'player_season_stats_season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
+    db.seasons.hasMany(db.team_season_stats, {
+      as: 'team_season_stats_season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.seasons.belongsTo(db.leagues, {
+      as: 'leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.seasons.belongsTo(db.leagues, {
+      as: 'league',
+      foreignKey: {
+        name: 'leagueId',
+      },
+      constraints: false,
+    });
+
+    db.seasons.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.seasons.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return seasons;
+};

backend/src/db/models/team_season_stats.js

@@ -0,0 +1,69 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const team_season_stats = sequelize.define(
+    'team_season_stats',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  team_season_stats.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.team_season_stats.belongsTo(db.leagues, {
+      as: 'leagues',
+      foreignKey: {
+        name: 'leaguesId',
+      },
+      constraints: false,
+    });
+
+    db.team_season_stats.belongsTo(db.teams, {
+      as: 'team',
+      foreignKey: {
+        name: 'teamId',
+      },
+      constraints: false,
+    });
+
+    db.team_season_stats.belongsTo(db.seasons, {
+      as: 'season',
+      foreignKey: {
+        name: 'seasonId',
+      },
+      constraints: false,
+    });
+
+    db.team_season_stats.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.team_season_stats.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return team_season_stats;
+};

backend/src/db/models/teams.js

@@ -68,6 +68,22 @@ module.exports = function (sequelize, DataTypes) {
       constraints: false,
     });
 
+    db.teams.hasMany(db.player_game_scores, {
+      as: 'player_game_scores_team',
+      foreignKey: {
+        name: 'teamId',
+      },
+      constraints: false,
+    });
+
+    db.teams.hasMany(db.team_season_stats, {
+      as: 'team_season_stats_team',
+      foreignKey: {
+        name: 'teamId',
+      },
+      constraints: false,
+    });
+
     //end loop
 
     db.teams.belongsTo(db.leagues, {

backend/src/db/seeders/20200430130760-user-roles.js

@@ -104,6 +104,10 @@ module.exports = {
       'roles',
       'permissions',
       'leagues',
+      'seasons',
+      'player_game_scores',
+      'player_season_stats',
+      'team_season_stats',
       ,
     ];
     await queryInterface.bulkInsert(
@@ -682,6 +686,106 @@ primary key ("roles_permissionsId", "permissionId")
         permissionId: getId('DELETE_VENUES'),
       },
 
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_SEASONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_PLAYER_GAME_SCORES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_PLAYER_SEASON_STATS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_TEAM_SEASON_STATS'),
+      },
+
       {
         createdAt,
         updatedAt,
@@ -882,6 +986,106 @@ primary key ("roles_permissionsId", "permissionId")
         permissionId: getId('DELETE_LEAGUES'),
       },
 
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_SEASONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_SEASONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_PLAYER_GAME_SCORES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_PLAYER_GAME_SCORES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_PLAYER_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_PLAYER_SEASON_STATS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_TEAM_SEASON_STATS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_TEAM_SEASON_STATS'),
+      },
+
       {
         createdAt,
         updatedAt,

backend/src/db/seeders/20250902184514.js

@@ -0,0 +1,87 @@
+const { v4: uuid } = require('uuid');
+const db = require('../models');
+const Sequelize = require('sequelize');
+const config = require('../../config');
+
+module.exports = {
+  /**
+   * @param{import("sequelize").QueryInterface} queryInterface
+   * @return {Promise<void>}
+   */
+  async up(queryInterface) {
+    const createdAt = new Date();
+    const updatedAt = new Date();
+
+    /** @type {Map<string, string>} */
+    const idMap = new Map();
+
+    /**
+     * @param {string} key
+     * @return {string}
+     */
+    function getId(key) {
+      if (idMap.has(key)) {
+        return idMap.get(key);
+      }
+      const id = uuid();
+      idMap.set(key, id);
+      return id;
+    }
+
+    /**
+     * @param {string} name
+     */
+    function createPermissions(name) {
+      return [
+        {
+          id: getId(`CREATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `CREATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`READ_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `READ_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`UPDATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `UPDATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`DELETE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `DELETE_${name.toUpperCase()}`,
+        },
+      ];
+    }
+
+    const entities = ['seasons'];
+
+    const createdPermissions = entities.flatMap(createPermissions);
+
+    // Add permissions to database
+    await queryInterface.bulkInsert('permissions', createdPermissions);
+    // Get permissions ids
+    const permissionsIds = createdPermissions.map((p) => p.id);
+    // Get admin role
+    const adminRole = await db.roles.findOne({
+      where: { name: config.roles.super_admin },
+    });
+
+    if (adminRole) {
+      // Add permissions to admin role if it exists
+      await adminRole.addPermissions(permissionsIds);
+    }
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete(
+      'permissions',
+      entities.flatMap(createPermissions),
+    );
+  },
+};

backend/src/db/seeders/20250902184826.js

@@ -0,0 +1,87 @@
+const { v4: uuid } = require('uuid');
+const db = require('../models');
+const Sequelize = require('sequelize');
+const config = require('../../config');
+
+module.exports = {
+  /**
+   * @param{import("sequelize").QueryInterface} queryInterface
+   * @return {Promise<void>}
+   */
+  async up(queryInterface) {
+    const createdAt = new Date();
+    const updatedAt = new Date();
+
+    /** @type {Map<string, string>} */
+    const idMap = new Map();
+
+    /**
+     * @param {string} key
+     * @return {string}
+     */
+    function getId(key) {
+      if (idMap.has(key)) {
+        return idMap.get(key);
+      }
+      const id = uuid();
+      idMap.set(key, id);
+      return id;
+    }
+
+    /**
+     * @param {string} name
+     */
+    function createPermissions(name) {
+      return [
+        {
+          id: getId(`CREATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `CREATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`READ_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `READ_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`UPDATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `UPDATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`DELETE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `DELETE_${name.toUpperCase()}`,
+        },
+      ];
+    }
+
+    const entities = ['player_game_scores'];
+
+    const createdPermissions = entities.flatMap(createPermissions);
+
+    // Add permissions to database
+    await queryInterface.bulkInsert('permissions', createdPermissions);
+    // Get permissions ids
+    const permissionsIds = createdPermissions.map((p) => p.id);
+    // Get admin role
+    const adminRole = await db.roles.findOne({
+      where: { name: config.roles.super_admin },
+    });
+
+    if (adminRole) {
+      // Add permissions to admin role if it exists
+      await adminRole.addPermissions(permissionsIds);
+    }
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete(
+      'permissions',
+      entities.flatMap(createPermissions),
+    );
+  },
+};

backend/src/db/seeders/20250902185104.js

@@ -0,0 +1,87 @@
+const { v4: uuid } = require('uuid');
+const db = require('../models');
+const Sequelize = require('sequelize');
+const config = require('../../config');
+
+module.exports = {
+  /**
+   * @param{import("sequelize").QueryInterface} queryInterface
+   * @return {Promise<void>}
+   */
+  async up(queryInterface) {
+    const createdAt = new Date();
+    const updatedAt = new Date();
+
+    /** @type {Map<string, string>} */
+    const idMap = new Map();
+
+    /**
+     * @param {string} key
+     * @return {string}
+     */
+    function getId(key) {
+      if (idMap.has(key)) {
+        return idMap.get(key);
+      }
+      const id = uuid();
+      idMap.set(key, id);
+      return id;
+    }
+
+    /**
+     * @param {string} name
+     */
+    function createPermissions(name) {
+      return [
+        {
+          id: getId(`CREATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `CREATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`READ_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `READ_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`UPDATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `UPDATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`DELETE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `DELETE_${name.toUpperCase()}`,
+        },
+      ];
+    }
+
+    const entities = ['player_season_stats'];
+
+    const createdPermissions = entities.flatMap(createPermissions);
+
+    // Add permissions to database
+    await queryInterface.bulkInsert('permissions', createdPermissions);
+    // Get permissions ids
+    const permissionsIds = createdPermissions.map((p) => p.id);
+    // Get admin role
+    const adminRole = await db.roles.findOne({
+      where: { name: config.roles.super_admin },
+    });
+
+    if (adminRole) {
+      // Add permissions to admin role if it exists
+      await adminRole.addPermissions(permissionsIds);
+    }
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete(
+      'permissions',
+      entities.flatMap(createPermissions),
+    );
+  },
+};

backend/src/db/seeders/20250902185509.js

@@ -0,0 +1,87 @@
+const { v4: uuid } = require('uuid');
+const db = require('../models');
+const Sequelize = require('sequelize');
+const config = require('../../config');
+
+module.exports = {
+  /**
+   * @param{import("sequelize").QueryInterface} queryInterface
+   * @return {Promise<void>}
+   */
+  async up(queryInterface) {
+    const createdAt = new Date();
+    const updatedAt = new Date();
+
+    /** @type {Map<string, string>} */
+    const idMap = new Map();
+
+    /**
+     * @param {string} key
+     * @return {string}
+     */
+    function getId(key) {
+      if (idMap.has(key)) {
+        return idMap.get(key);
+      }
+      const id = uuid();
+      idMap.set(key, id);
+      return id;
+    }
+
+    /**
+     * @param {string} name
+     */
+    function createPermissions(name) {
+      return [
+        {
+          id: getId(`CREATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `CREATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`READ_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `READ_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`UPDATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `UPDATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`DELETE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `DELETE_${name.toUpperCase()}`,
+        },
+      ];
+    }
+
+    const entities = ['team_season_stats'];
+
+    const createdPermissions = entities.flatMap(createPermissions);
+
+    // Add permissions to database
+    await queryInterface.bulkInsert('permissions', createdPermissions);
+    // Get permissions ids
+    const permissionsIds = createdPermissions.map((p) => p.id);
+    // Get admin role
+    const adminRole = await db.roles.findOne({
+      where: { name: config.roles.super_admin },
+    });
+
+    if (adminRole) {
+      // Add permissions to admin role if it exists
+      await adminRole.addPermissions(permissionsIds);
+    }
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete(
+      'permissions',
+      entities.flatMap(createPermissions),
+    );
+  },
+};

backend/src/index.js

@@ -37,6 +37,14 @@ const permissionsRoutes = require('./routes/permissions');
 
 const leaguesRoutes = require('./routes/leagues');
 
+const seasonsRoutes = require('./routes/seasons');
+
+const player_game_scoresRoutes = require('./routes/player_game_scores');
+
+const player_season_statsRoutes = require('./routes/player_season_stats');
+
+const team_season_statsRoutes = require('./routes/team_season_stats');
+
 const getBaseUrl = (url) => {
   if (!url) return '';
   return url.endsWith('/api') ? url.slice(0, -4) : url;
@@ -150,6 +158,30 @@ app.use(
   leaguesRoutes,
 );
 
+app.use(
+  '/api/seasons',
+  passport.authenticate('jwt', { session: false }),
+  seasonsRoutes,
+);
+
+app.use(
+  '/api/player_game_scores',
+  passport.authenticate('jwt', { session: false }),
+  player_game_scoresRoutes,
+);
+
+app.use(
+  '/api/player_season_stats',
+  passport.authenticate('jwt', { session: false }),
+  player_season_statsRoutes,
+);
+
+app.use(
+  '/api/team_season_stats',
+  passport.authenticate('jwt', { session: false }),
+  team_season_statsRoutes,
+);
+
 app.use(
   '/api/openai',
   passport.authenticate('jwt', { session: false }),

backend/src/routes/leagues.js

@@ -25,6 +25,9 @@ router.use(checkCrudPermissions('leagues'));
  *          name:
  *            type: string
  *            default: name
+ *          handicapformula:
+ *            type: string
+ *            default: handicapformula
 
  */
 
@@ -310,7 +313,7 @@ router.get(
       currentUser,
     });
     if (filetype && filetype === 'csv') {
-      const fields = ['id', 'name'];
+      const fields = ['id', 'name', 'handicapformula'];
       const opts = { fields };
       try {
         const csv = parse(payload.rows, opts);

backend/src/routes/player_game_scores.js

@@ -0,0 +1,455 @@
+const express = require('express');
+
+const Player_game_scoresService = require('../services/player_game_scores');
+const Player_game_scoresDBApi = require('../db/api/player_game_scores');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('player_game_scores'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Player_game_scores:
+ *        type: object
+ *        properties:
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Player_game_scores
+ *   description: The Player_game_scores managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/player_game_scores:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Player_game_scores"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Player_game_scoresService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Player_game_scores]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Player_game_scores"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Player_game_scoresService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_game_scores/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Player_game_scores"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Player_game_scoresService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/player_game_scores/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Player_game_scoresService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_game_scores/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await Player_game_scoresService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_game_scores:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Get all player_game_scores
+ *      description: Get all player_game_scores
+ *      responses:
+ *        200:
+ *          description: Player_game_scores list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_game_scores"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Player_game_scoresDBApi.findAll(
+      req.query,
+      globalAccess,
+      { currentUser },
+    );
+    if (filetype && filetype === 'csv') {
+      const fields = ['id'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_game_scores/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Count all player_game_scores
+ *      description: Count all player_game_scores
+ *      responses:
+ *        200:
+ *          description: Player_game_scores count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_game_scores"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Player_game_scoresDBApi.findAll(
+      req.query,
+      globalAccess,
+      { countOnly: true, currentUser },
+    );
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_game_scores/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Find all player_game_scores that match search criteria
+ *      description: Find all player_game_scores that match search criteria
+ *      responses:
+ *        200:
+ *          description: Player_game_scores list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_game_scores"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await Player_game_scoresDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/player_game_scores/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_game_scores]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_game_scores"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await Player_game_scoresDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/player_season_stats.js

@@ -0,0 +1,483 @@
+const express = require('express');
+
+const Player_season_statsService = require('../services/player_season_stats');
+const Player_season_statsDBApi = require('../db/api/player_season_stats');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('player_season_stats'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Player_season_stats:
+ *        type: object
+ *        properties:
+
+ *          totalpoints:
+ *            type: integer
+ *            format: int64
+ *          gamesplayed:
+ *            type: integer
+ *            format: int64
+ *          eightballruns:
+ *            type: integer
+ *            format: int64
+ *          eightballbreaks:
+ *            type: integer
+ *            format: int64
+ *          nineballruns:
+ *            type: integer
+ *            format: int64
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Player_season_stats
+ *   description: The Player_season_stats managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/player_season_stats:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Player_season_stats"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Player_season_statsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Player_season_stats]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Player_season_stats"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Player_season_statsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_season_stats/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Player_season_stats"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Player_season_statsService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/player_season_stats/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Player_season_statsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_season_stats/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await Player_season_statsService.deleteByIds(
+      req.body.data,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_season_stats:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Get all player_season_stats
+ *      description: Get all player_season_stats
+ *      responses:
+ *        200:
+ *          description: Player_season_stats list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Player_season_statsDBApi.findAll(
+      req.query,
+      globalAccess,
+      { currentUser },
+    );
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'totalpoints',
+        'gamesplayed',
+        'eightballruns',
+        'eightballbreaks',
+        'nineballruns',
+      ];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_season_stats/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Count all player_season_stats
+ *      description: Count all player_season_stats
+ *      responses:
+ *        200:
+ *          description: Player_season_stats count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Player_season_statsDBApi.findAll(
+      req.query,
+      globalAccess,
+      { countOnly: true, currentUser },
+    );
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/player_season_stats/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Find all player_season_stats that match search criteria
+ *      description: Find all player_season_stats that match search criteria
+ *      responses:
+ *        200:
+ *          description: Player_season_stats list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Player_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await Player_season_statsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/player_season_stats/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Player_season_stats]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Player_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await Player_season_statsDBApi.findBy({
+      id: req.params.id,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/seasons.js

@@ -0,0 +1,452 @@
+const express = require('express');
+
+const SeasonsService = require('../services/seasons');
+const SeasonsDBApi = require('../db/api/seasons');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('seasons'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Seasons:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Seasons
+ *   description: The Seasons managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/seasons:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Seasons"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Seasons"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await SeasonsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Seasons]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Seasons"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Seasons"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await SeasonsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/seasons/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Seasons"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Seasons"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await SeasonsService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/seasons/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Seasons"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await SeasonsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/seasons/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Seasons"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await SeasonsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/seasons:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Get all seasons
+ *      description: Get all seasons
+ *      responses:
+ *        200:
+ *          description: Seasons list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Seasons"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await SeasonsDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'name', 'startdate', 'enddate'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/seasons/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Count all seasons
+ *      description: Count all seasons
+ *      responses:
+ *        200:
+ *          description: Seasons count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Seasons"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await SeasonsDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/seasons/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Find all seasons that match search criteria
+ *      description: Find all seasons that match search criteria
+ *      responses:
+ *        200:
+ *          description: Seasons list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Seasons"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await SeasonsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/seasons/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Seasons]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Seasons"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await SeasonsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/team_season_stats.js

@@ -0,0 +1,455 @@
+const express = require('express');
+
+const Team_season_statsService = require('../services/team_season_stats');
+const Team_season_statsDBApi = require('../db/api/team_season_stats');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('team_season_stats'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Team_season_stats:
+ *        type: object
+ *        properties:
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Team_season_stats
+ *   description: The Team_season_stats managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/team_season_stats:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Team_season_stats"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Team_season_statsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Team_season_stats]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Team_season_stats"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Team_season_statsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/team_season_stats/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Team_season_stats"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Team_season_statsService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/team_season_stats/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Team_season_statsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/team_season_stats/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await Team_season_statsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/team_season_stats:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Get all team_season_stats
+ *      description: Get all team_season_stats
+ *      responses:
+ *        200:
+ *          description: Team_season_stats list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Team_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Team_season_statsDBApi.findAll(
+      req.query,
+      globalAccess,
+      { currentUser },
+    );
+    if (filetype && filetype === 'csv') {
+      const fields = ['id'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/team_season_stats/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Count all team_season_stats
+ *      description: Count all team_season_stats
+ *      responses:
+ *        200:
+ *          description: Team_season_stats count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Team_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Team_season_statsDBApi.findAll(
+      req.query,
+      globalAccess,
+      { countOnly: true, currentUser },
+    );
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/team_season_stats/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Find all team_season_stats that match search criteria
+ *      description: Find all team_season_stats that match search criteria
+ *      responses:
+ *        200:
+ *          description: Team_season_stats list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Team_season_stats"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await Team_season_statsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/team_season_stats/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Team_season_stats]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Team_season_stats"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await Team_season_statsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/services/player_game_scores.js

@@ -0,0 +1,121 @@
+const db = require('../db/models');
+const Player_game_scoresDBApi = require('../db/api/player_game_scores');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class Player_game_scoresService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await Player_game_scoresDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await Player_game_scoresDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let player_game_scores = await Player_game_scoresDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!player_game_scores) {
+        throw new ValidationError('player_game_scoresNotFound');
+      }
+
+      const updatedPlayer_game_scores = await Player_game_scoresDBApi.update(
+        id,
+        data,
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+      return updatedPlayer_game_scores;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Player_game_scoresDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Player_game_scoresDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/player_season_stats.js

@@ -0,0 +1,121 @@
+const db = require('../db/models');
+const Player_season_statsDBApi = require('../db/api/player_season_stats');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class Player_season_statsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await Player_season_statsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await Player_season_statsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let player_season_stats = await Player_season_statsDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!player_season_stats) {
+        throw new ValidationError('player_season_statsNotFound');
+      }
+
+      const updatedPlayer_season_stats = await Player_season_statsDBApi.update(
+        id,
+        data,
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+      return updatedPlayer_season_stats;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Player_season_statsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Player_season_statsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/search.js

@@ -49,12 +49,26 @@ module.exports = class SearchService {
 
         venues: ['name', 'address'],
 
-        leagues: ['name'],
+        leagues: ['name', 'handicapformula'],
+
+        seasons: ['name'],
       };
       const columnsInt = {
         games: ['team_score', 'opponent_score'],
 
         players: ['total_points', 'games_played'],
+
+        player_season_stats: [
+          'totalpoints',
+
+          'gamesplayed',
+
+          'eightballruns',
+
+          'eightballbreaks',
+
+          'nineballruns',
+        ],
       };
 
       let allFoundRecords = [];

backend/src/services/seasons.js

@@ -0,0 +1,114 @@
+const db = require('../db/models');
+const SeasonsDBApi = require('../db/api/seasons');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class SeasonsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await SeasonsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await SeasonsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let seasons = await SeasonsDBApi.findBy({ id }, { transaction });
+
+      if (!seasons) {
+        throw new ValidationError('seasonsNotFound');
+      }
+
+      const updatedSeasons = await SeasonsDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedSeasons;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await SeasonsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await SeasonsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/team_season_stats.js

@@ -0,0 +1,121 @@
+const db = require('../db/models');
+const Team_season_statsDBApi = require('../db/api/team_season_stats');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class Team_season_statsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await Team_season_statsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await Team_season_statsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let team_season_stats = await Team_season_statsDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!team_season_stats) {
+        throw new ValidationError('team_season_statsNotFound');
+      }
+
+      const updatedTeam_season_stats = await Team_season_statsDBApi.update(
+        id,
+        data,
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+      return updatedTeam_season_stats;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Team_season_statsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Team_season_statsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

frontend/src/components/Games/CardGames.tsx

@@ -128,6 +128,17 @@ const CardGames = ({
                     </div>
                   </dd>
                 </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Season
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.seasonsOneListFormatter(item.season)}
+                    </div>
+                  </dd>
+                </div>
               </dl>
             </li>
           ))}

frontend/src/components/Games/ListGames.tsx

@@ -83,6 +83,13 @@ const ListGames = ({
                       </p>
                       <p className={'line-clamp-2'}>{item.opponent_score}</p>
                     </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Season</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.seasonsOneListFormatter(item.season)}
+                      </p>
+                    </div>
                   </Link>
                   <ListActionsPopover
                     onDelete={onDelete}

frontend/src/components/Games/configureGamesCols.tsx

@@ -121,6 +121,26 @@ export const loadColumns = async (
       type: 'number',
     },
 
+    {
+      field: 'season',
+      headerName: 'Season',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('seasons'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
     {
       field: 'actions',
       type: 'actions',

frontend/src/components/Leagues/CardLeagues.tsx

@@ -82,6 +82,17 @@ const CardLeagues = ({
                     <div className='font-medium line-clamp-4'>{item.name}</div>
                   </dd>
                 </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Handicapformula
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.handicapformula}
+                    </div>
+                  </dd>
+                </div>
               </dl>
             </li>
           ))}

frontend/src/components/Leagues/ListLeagues.tsx

@@ -55,6 +55,13 @@ const ListLeagues = ({
                       <p className={'text-xs   text-gray-500 '}>Name</p>
                       <p className={'line-clamp-2'}>{item.name}</p>
                     </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>
+                        Handicapformula
+                      </p>
+                      <p className={'line-clamp-2'}>{item.handicapformula}</p>
+                    </div>
                   </Link>
                   <ListActionsPopover
                     onDelete={onDelete}

frontend/src/components/Leagues/configureLeaguesCols.tsx

@@ -50,6 +50,18 @@ export const loadColumns = async (
       editable: hasUpdatePermission,
     },
 
+    {
+      field: 'handicapformula',
+      headerName: 'Handicapformula',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+    },
+
     {
       field: 'actions',
       type: 'actions',

frontend/src/components/Player_game_scores/CardPlayer_game_scores.tsx

@@ -0,0 +1,130 @@
+import React from 'react';
+import ImageField from '../ImageField';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import dataFormatter from '../../helpers/dataFormatter';
+import { Pagination } from '../Pagination';
+import { saveFile } from '../../helpers/fileSaver';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  player_game_scores: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const CardPlayer_game_scores = ({
+  player_game_scores,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const asideScrollbarsStyle = useAppSelector(
+    (state) => state.style.asideScrollbarsStyle,
+  );
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+  const darkMode = useAppSelector((state) => state.style.darkMode);
+  const corners = useAppSelector((state) => state.style.corners);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_PLAYER_GAME_SCORES',
+  );
+
+  return (
+    <div className={'p-4'}>
+      {loading && <LoadingSpinner />}
+      <ul
+        role='list'
+        className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
+      >
+        {!loading &&
+          player_game_scores.map((item, index) => (
+            <li
+              key={item.id}
+              className={`overflow-hidden ${
+                corners !== 'rounded-full' ? corners : 'rounded-3xl'
+              } border  ${focusRing} border-gray-200 dark:border-dark-700 ${
+                darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
+              }`}
+            >
+              <div
+                className={`flex items-center ${bgColor} p-6  gap-x-4 border-b border-gray-900/5 bg-gray-50 dark:bg-dark-800 relative`}
+              >
+                <Link
+                  href={`/player_game_scores/player_game_scores-view/?id=${item.id}`}
+                  className='text-lg font-bold leading-6 line-clamp-1'
+                >
+                  {item.id}
+                </Link>
+
+                <div className='ml-auto '>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/player_game_scores/player_game_scores-edit/?id=${item.id}`}
+                    pathView={`/player_game_scores/player_game_scores-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </div>
+              <dl className='divide-y  divide-stone-300   dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>Game</dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.gamesOneListFormatter(item.game)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Player
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.playersOneListFormatter(item.player)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>Team</dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.teamsOneListFormatter(item.team)}
+                    </div>
+                  </dd>
+                </div>
+              </dl>
+            </li>
+          ))}
+        {!loading && player_game_scores.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </ul>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </div>
+  );
+};
+
+export default CardPlayer_game_scores;

frontend/src/components/Player_game_scores/ListPlayer_game_scores.tsx

@@ -0,0 +1,106 @@
+import React from 'react';
+import CardBox from '../CardBox';
+import ImageField from '../ImageField';
+import dataFormatter from '../../helpers/dataFormatter';
+import { saveFile } from '../../helpers/fileSaver';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import { Pagination } from '../Pagination';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  player_game_scores: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const ListPlayer_game_scores = ({
+  player_game_scores,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_PLAYER_GAME_SCORES',
+  );
+
+  const corners = useAppSelector((state) => state.style.corners);
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+
+  return (
+    <>
+      <div className='relative overflow-x-auto p-4 space-y-4'>
+        {loading && <LoadingSpinner />}
+        {!loading &&
+          player_game_scores.map((item) => (
+            <div key={item.id}>
+              <CardBox hasTable isList className={'rounded shadow-none'}>
+                <div
+                  className={`flex rounded  dark:bg-dark-900  border  border-stone-300  items-center overflow-hidden`}
+                >
+                  <Link
+                    href={`/player_game_scores/player_game_scores-view/?id=${item.id}`}
+                    className={
+                      'flex-1 px-4 py-6 h-24 flex divide-x-2  divide-stone-300   items-center overflow-hidden`}> dark:divide-dark-700 overflow-x-auto'
+                    }
+                  >
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Game</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.gamesOneListFormatter(item.game)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Player</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.playersOneListFormatter(item.player)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Team</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.teamsOneListFormatter(item.team)}
+                      </p>
+                    </div>
+                  </Link>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/player_game_scores/player_game_scores-edit/?id=${item.id}`}
+                    pathView={`/player_game_scores/player_game_scores-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </CardBox>
+            </div>
+          ))}
+        {!loading && player_game_scores.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </div>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </>
+  );
+};
+
+export default ListPlayer_game_scores;

frontend/src/components/Player_game_scores/TablePlayer_game_scores.tsx

@@ -0,0 +1,486 @@
+import React, { useEffect, useState, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import { ToastContainer, toast } from 'react-toastify';
+import BaseButton from '../BaseButton';
+import CardBoxModal from '../CardBoxModal';
+import CardBox from '../CardBox';
+import {
+  fetch,
+  update,
+  deleteItem,
+  setRefetch,
+  deleteItemsByIds,
+} from '../../stores/player_game_scores/player_game_scoresSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { Field, Form, Formik } from 'formik';
+import { DataGrid, GridColDef } from '@mui/x-data-grid';
+import { loadColumns } from './configurePlayer_game_scoresCols';
+import _ from 'lodash';
+import dataFormatter from '../../helpers/dataFormatter';
+import { dataGridStyles } from '../../styles';
+
+const perPage = 10;
+
+const TableSamplePlayer_game_scores = ({
+  filterItems,
+  setFilterItems,
+  filters,
+  showGrid,
+}) => {
+  const notify = (type, msg) => toast(msg, { type, position: 'bottom-center' });
+
+  const dispatch = useAppDispatch();
+  const router = useRouter();
+
+  const pagesList = [];
+  const [id, setId] = useState(null);
+  const [currentPage, setCurrentPage] = useState(0);
+  const [filterRequest, setFilterRequest] = React.useState('');
+  const [columns, setColumns] = useState<GridColDef[]>([]);
+  const [selectedRows, setSelectedRows] = useState([]);
+  const [sortModel, setSortModel] = useState([
+    {
+      field: '',
+      sort: 'desc',
+    },
+  ]);
+
+  const {
+    player_game_scores,
+    loading,
+    count,
+    notify: player_game_scoresNotify,
+    refetch,
+  } = useAppSelector((state) => state.player_game_scores);
+  const { currentUser } = useAppSelector((state) => state.auth);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+  const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
+  const corners = useAppSelector((state) => state.style.corners);
+  const numPages =
+    Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
+  for (let i = 0; i < numPages; i++) {
+    pagesList.push(i);
+  }
+
+  const loadData = async (page = currentPage, request = filterRequest) => {
+    if (page !== currentPage) setCurrentPage(page);
+    if (request !== filterRequest) setFilterRequest(request);
+    const { sort, field } = sortModel[0];
+
+    const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
+    dispatch(fetch({ limit: perPage, page, query }));
+  };
+
+  useEffect(() => {
+    if (player_game_scoresNotify.showNotification) {
+      notify(
+        player_game_scoresNotify.typeNotification,
+        player_game_scoresNotify.textNotification,
+      );
+    }
+  }, [player_game_scoresNotify.showNotification]);
+
+  useEffect(() => {
+    if (!currentUser) return;
+    loadData();
+  }, [sortModel, currentUser]);
+
+  useEffect(() => {
+    if (refetch) {
+      loadData(0);
+      dispatch(setRefetch(false));
+    }
+  }, [refetch, dispatch]);
+
+  const [isModalInfoActive, setIsModalInfoActive] = useState(false);
+  const [isModalTrashActive, setIsModalTrashActive] = useState(false);
+
+  const handleModalAction = () => {
+    setIsModalInfoActive(false);
+    setIsModalTrashActive(false);
+  };
+
+  const handleDeleteModalAction = (id: string) => {
+    setId(id);
+    setIsModalTrashActive(true);
+  };
+  const handleDeleteAction = async () => {
+    if (id) {
+      await dispatch(deleteItem(id));
+      await loadData(0);
+      setIsModalTrashActive(false);
+    }
+  };
+
+  const generateFilterRequests = useMemo(() => {
+    let request = '&';
+    filterItems.forEach((item) => {
+      const isRangeFilter = filters.find(
+        (filter) =>
+          filter.title === item.fields.selectedField &&
+          (filter.number || filter.date),
+      );
+
+      if (isRangeFilter) {
+        const from = item.fields.filterValueFrom;
+        const to = item.fields.filterValueTo;
+        if (from) {
+          request += `${item.fields.selectedField}Range=${from}&`;
+        }
+        if (to) {
+          request += `${item.fields.selectedField}Range=${to}&`;
+        }
+      } else {
+        const value = item.fields.filterValue;
+        if (value) {
+          request += `${item.fields.selectedField}=${value}&`;
+        }
+      }
+    });
+    return request;
+  }, [filterItems, filters]);
+
+  const deleteFilter = (value) => {
+    const newItems = filterItems.filter((item) => item.id !== value);
+
+    if (newItems.length) {
+      setFilterItems(newItems);
+    } else {
+      loadData(0, '');
+
+      setFilterItems(newItems);
+    }
+  };
+
+  const handleSubmit = () => {
+    loadData(0, generateFilterRequests);
+  };
+
+  const handleChange = (id) => (e) => {
+    const value = e.target.value;
+    const name = e.target.name;
+
+    setFilterItems(
+      filterItems.map((item) => {
+        if (item.id !== id) return item;
+        if (name === 'selectedField') return { id, fields: { [name]: value } };
+
+        return { id, fields: { ...item.fields, [name]: value } };
+      }),
+    );
+  };
+
+  const handleReset = () => {
+    setFilterItems([]);
+    loadData(0, '');
+  };
+
+  const onPageChange = (page: number) => {
+    loadData(page);
+    setCurrentPage(page);
+  };
+
+  useEffect(() => {
+    if (!currentUser) return;
+
+    loadColumns(
+      handleDeleteModalAction,
+      `player_game_scores`,
+      currentUser,
+    ).then((newCols) => setColumns(newCols));
+  }, [currentUser]);
+
+  const handleTableSubmit = async (id: string, data) => {
+    if (!_.isEmpty(data)) {
+      await dispatch(update({ id, data }))
+        .unwrap()
+        .then((res) => res)
+        .catch((err) => {
+          throw new Error(err);
+        });
+    }
+  };
+
+  const onDeleteRows = async (selectedRows) => {
+    await dispatch(deleteItemsByIds(selectedRows));
+    await loadData(0);
+  };
+
+  const controlClasses =
+    'w-full py-2 px-2 my-2   rounded dark:placeholder-gray-400 ' +
+    ` ${bgColor} ${focusRing} ${corners} ` +
+    'dark:bg-slate-800 border';
+
+  const dataGrid = (
+    <div className='relative overflow-x-auto'>
+      <DataGrid
+        autoHeight
+        rowHeight={64}
+        sx={dataGridStyles}
+        className={'datagrid--table'}
+        getRowClassName={() => `datagrid--row`}
+        rows={player_game_scores ?? []}
+        columns={columns}
+        initialState={{
+          pagination: {
+            paginationModel: {
+              pageSize: 10,
+            },
+          },
+        }}
+        disableRowSelectionOnClick
+        onProcessRowUpdateError={(params) => {
+          console.log('Error', params);
+        }}
+        processRowUpdate={async (newRow, oldRow) => {
+          const data = dataFormatter.dataGridEditFormatter(newRow);
+
+          try {
+            await handleTableSubmit(newRow.id, data);
+            return newRow;
+          } catch {
+            return oldRow;
+          }
+        }}
+        sortingMode={'server'}
+        checkboxSelection
+        onRowSelectionModelChange={(ids) => {
+          setSelectedRows(ids);
+        }}
+        onSortModelChange={(params) => {
+          params.length
+            ? setSortModel(params)
+            : setSortModel([{ field: '', sort: 'desc' }]);
+        }}
+        rowCount={count}
+        pageSizeOptions={[10]}
+        paginationMode={'server'}
+        loading={loading}
+        onPaginationModelChange={(params) => {
+          onPageChange(params.page);
+        }}
+      />
+    </div>
+  );
+
+  return (
+    <>
+      {filterItems && Array.isArray(filterItems) && filterItems.length ? (
+        <CardBox>
+          <Formik
+            initialValues={{
+              checkboxes: ['lorem'],
+              switches: ['lorem'],
+              radio: 'lorem',
+            }}
+            onSubmit={() => null}
+          >
+            <Form>
+              <>
+                {filterItems &&
+                  filterItems.map((filterItem) => {
+                    return (
+                      <div key={filterItem.id} className='flex mb-4'>
+                        <div className='flex flex-col w-full mr-3'>
+                          <div className='  text-gray-500  font-bold'>
+                            Filter
+                          </div>
+                          <Field
+                            className={controlClasses}
+                            name='selectedField'
+                            id='selectedField'
+                            component='select'
+                            value={filterItem?.fields?.selectedField || ''}
+                            onChange={handleChange(filterItem.id)}
+                          >
+                            {filters.map((selectOption) => (
+                              <option
+                                key={selectOption.title}
+                                value={`${selectOption.title}`}
+                              >
+                                {selectOption.label}
+                              </option>
+                            ))}
+                          </Field>
+                        </div>
+                        {filters.find(
+                          (filter) =>
+                            filter.title === filterItem?.fields?.selectedField,
+                        )?.type === 'enum' ? (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='text-gray-500 font-bold'>Value</div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              id='filterValue'
+                              component='select'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            >
+                              <option value=''>Select Value</option>
+                              {filters
+                                .find(
+                                  (filter) =>
+                                    filter.title ===
+                                    filterItem?.fields?.selectedField,
+                                )
+                                ?.options?.map((option) => (
+                                  <option key={option} value={option}>
+                                    {option}
+                                  </option>
+                                ))}
+                            </Field>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.number ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.date ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                type='datetime-local'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                type='datetime-local'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='  text-gray-500  font-bold'>
+                              Contains
+                            </div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              placeholder='Contained'
+                              id='filterValue'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            />
+                          </div>
+                        )}
+                        <div className='flex flex-col'>
+                          <div className='  text-gray-500  font-bold'>
+                            Action
+                          </div>
+                          <BaseButton
+                            className='my-2'
+                            type='reset'
+                            color='danger'
+                            label='Delete'
+                            onClick={() => {
+                              deleteFilter(filterItem.id);
+                            }}
+                          />
+                        </div>
+                      </div>
+                    );
+                  })}
+                <div className='flex'>
+                  <BaseButton
+                    className='my-2 mr-3'
+                    color='success'
+                    label='Apply'
+                    onClick={handleSubmit}
+                  />
+                  <BaseButton
+                    className='my-2'
+                    color='info'
+                    label='Cancel'
+                    onClick={handleReset}
+                  />
+                </div>
+              </>
+            </Form>
+          </Formik>
+        </CardBox>
+      ) : null}
+      <CardBoxModal
+        title='Please confirm'
+        buttonColor='info'
+        buttonLabel={loading ? 'Deleting...' : 'Confirm'}
+        isActive={isModalTrashActive}
+        onConfirm={handleDeleteAction}
+        onCancel={handleModalAction}
+      >
+        <p>Are you sure you want to delete this item?</p>
+      </CardBoxModal>
+
+      {dataGrid}
+
+      {selectedRows.length > 0 &&
+        createPortal(
+          <BaseButton
+            className='me-4'
+            color='danger'
+            label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
+            onClick={() => onDeleteRows(selectedRows)}
+          />,
+          document.getElementById('delete-rows-button'),
+        )}
+      <ToastContainer />
+    </>
+  );
+};
+
+export default TableSamplePlayer_game_scores;

frontend/src/components/Player_game_scores/configurePlayer_game_scoresCols.tsx

@@ -0,0 +1,122 @@
+import React from 'react';
+import BaseIcon from '../BaseIcon';
+import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
+import axios from 'axios';
+import {
+  GridActionsCellItem,
+  GridRowParams,
+  GridValueGetterParams,
+} from '@mui/x-data-grid';
+import ImageField from '../ImageField';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import DataGridMultiSelect from '../DataGridMultiSelect';
+import ListActionsPopover from '../ListActionsPopover';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Params = (id: string) => void;
+
+export const loadColumns = async (
+  onDelete: Params,
+  entityName: string,
+
+  user,
+) => {
+  async function callOptionsApi(entityName: string) {
+    if (!hasPermission(user, 'READ_' + entityName.toUpperCase())) return [];
+
+    try {
+      const data = await axios(`/${entityName}/autocomplete?limit=100`);
+      return data.data;
+    } catch (error) {
+      console.log(error);
+      return [];
+    }
+  }
+
+  const hasUpdatePermission = hasPermission(user, 'UPDATE_PLAYER_GAME_SCORES');
+
+  return [
+    {
+      field: 'game',
+      headerName: 'Game',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('games'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'player',
+      headerName: 'Player',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('players'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'team',
+      headerName: 'Team',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('teams'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'actions',
+      type: 'actions',
+      minWidth: 30,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+      getActions: (params: GridRowParams) => {
+        return [
+          <div key={params?.row?.id}>
+            <ListActionsPopover
+              onDelete={onDelete}
+              itemId={params?.row?.id}
+              pathEdit={`/player_game_scores/player_game_scores-edit/?id=${params?.row?.id}`}
+              pathView={`/player_game_scores/player_game_scores-view/?id=${params?.row?.id}`}
+              hasUpdatePermission={hasUpdatePermission}
+            />
+          </div>,
+        ];
+      },
+    },
+  ];
+};

frontend/src/components/Player_season_stats/CardPlayer_season_stats.tsx

@@ -0,0 +1,178 @@
+import React from 'react';
+import ImageField from '../ImageField';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import dataFormatter from '../../helpers/dataFormatter';
+import { Pagination } from '../Pagination';
+import { saveFile } from '../../helpers/fileSaver';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  player_season_stats: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const CardPlayer_season_stats = ({
+  player_season_stats,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const asideScrollbarsStyle = useAppSelector(
+    (state) => state.style.asideScrollbarsStyle,
+  );
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+  const darkMode = useAppSelector((state) => state.style.darkMode);
+  const corners = useAppSelector((state) => state.style.corners);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_PLAYER_SEASON_STATS',
+  );
+
+  return (
+    <div className={'p-4'}>
+      {loading && <LoadingSpinner />}
+      <ul
+        role='list'
+        className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
+      >
+        {!loading &&
+          player_season_stats.map((item, index) => (
+            <li
+              key={item.id}
+              className={`overflow-hidden ${
+                corners !== 'rounded-full' ? corners : 'rounded-3xl'
+              } border  ${focusRing} border-gray-200 dark:border-dark-700 ${
+                darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
+              }`}
+            >
+              <div
+                className={`flex items-center ${bgColor} p-6  gap-x-4 border-b border-gray-900/5 bg-gray-50 dark:bg-dark-800 relative`}
+              >
+                <Link
+                  href={`/player_season_stats/player_season_stats-view/?id=${item.id}`}
+                  className='text-lg font-bold leading-6 line-clamp-1'
+                >
+                  {item.gamesplayed}
+                </Link>
+
+                <div className='ml-auto '>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/player_season_stats/player_season_stats-edit/?id=${item.id}`}
+                    pathView={`/player_season_stats/player_season_stats-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </div>
+              <dl className='divide-y  divide-stone-300   dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Player
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.playersOneListFormatter(item.player)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Season
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.seasonsOneListFormatter(item.season)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Totalpoints
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.totalpoints}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Gamesplayed
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.gamesplayed}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Eightballruns
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.eightballruns}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Eightballbreaks
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.eightballbreaks}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Nineballruns
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {item.nineballruns}
+                    </div>
+                  </dd>
+                </div>
+              </dl>
+            </li>
+          ))}
+        {!loading && player_season_stats.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </ul>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </div>
+  );
+};
+
+export default CardPlayer_season_stats;

frontend/src/components/Player_season_stats/ListPlayer_season_stats.tsx

@@ -0,0 +1,128 @@
+import React from 'react';
+import CardBox from '../CardBox';
+import ImageField from '../ImageField';
+import dataFormatter from '../../helpers/dataFormatter';
+import { saveFile } from '../../helpers/fileSaver';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import { Pagination } from '../Pagination';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  player_season_stats: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const ListPlayer_season_stats = ({
+  player_season_stats,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_PLAYER_SEASON_STATS',
+  );
+
+  const corners = useAppSelector((state) => state.style.corners);
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+
+  return (
+    <>
+      <div className='relative overflow-x-auto p-4 space-y-4'>
+        {loading && <LoadingSpinner />}
+        {!loading &&
+          player_season_stats.map((item) => (
+            <div key={item.id}>
+              <CardBox hasTable isList className={'rounded shadow-none'}>
+                <div
+                  className={`flex rounded  dark:bg-dark-900  border  border-stone-300  items-center overflow-hidden`}
+                >
+                  <Link
+                    href={`/player_season_stats/player_season_stats-view/?id=${item.id}`}
+                    className={
+                      'flex-1 px-4 py-6 h-24 flex divide-x-2  divide-stone-300   items-center overflow-hidden`}> dark:divide-dark-700 overflow-x-auto'
+                    }
+                  >
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Player</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.playersOneListFormatter(item.player)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Season</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.seasonsOneListFormatter(item.season)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Totalpoints</p>
+                      <p className={'line-clamp-2'}>{item.totalpoints}</p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Gamesplayed</p>
+                      <p className={'line-clamp-2'}>{item.gamesplayed}</p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>
+                        Eightballruns
+                      </p>
+                      <p className={'line-clamp-2'}>{item.eightballruns}</p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>
+                        Eightballbreaks
+                      </p>
+                      <p className={'line-clamp-2'}>{item.eightballbreaks}</p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Nineballruns</p>
+                      <p className={'line-clamp-2'}>{item.nineballruns}</p>
+                    </div>
+                  </Link>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/player_season_stats/player_season_stats-edit/?id=${item.id}`}
+                    pathView={`/player_season_stats/player_season_stats-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </CardBox>
+            </div>
+          ))}
+        {!loading && player_season_stats.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </div>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </>
+  );
+};
+
+export default ListPlayer_season_stats;

frontend/src/components/Player_season_stats/TablePlayer_season_stats.tsx

@@ -0,0 +1,486 @@
+import React, { useEffect, useState, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import { ToastContainer, toast } from 'react-toastify';
+import BaseButton from '../BaseButton';
+import CardBoxModal from '../CardBoxModal';
+import CardBox from '../CardBox';
+import {
+  fetch,
+  update,
+  deleteItem,
+  setRefetch,
+  deleteItemsByIds,
+} from '../../stores/player_season_stats/player_season_statsSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { Field, Form, Formik } from 'formik';
+import { DataGrid, GridColDef } from '@mui/x-data-grid';
+import { loadColumns } from './configurePlayer_season_statsCols';
+import _ from 'lodash';
+import dataFormatter from '../../helpers/dataFormatter';
+import { dataGridStyles } from '../../styles';
+
+const perPage = 10;
+
+const TableSamplePlayer_season_stats = ({
+  filterItems,
+  setFilterItems,
+  filters,
+  showGrid,
+}) => {
+  const notify = (type, msg) => toast(msg, { type, position: 'bottom-center' });
+
+  const dispatch = useAppDispatch();
+  const router = useRouter();
+
+  const pagesList = [];
+  const [id, setId] = useState(null);
+  const [currentPage, setCurrentPage] = useState(0);
+  const [filterRequest, setFilterRequest] = React.useState('');
+  const [columns, setColumns] = useState<GridColDef[]>([]);
+  const [selectedRows, setSelectedRows] = useState([]);
+  const [sortModel, setSortModel] = useState([
+    {
+      field: '',
+      sort: 'desc',
+    },
+  ]);
+
+  const {
+    player_season_stats,
+    loading,
+    count,
+    notify: player_season_statsNotify,
+    refetch,
+  } = useAppSelector((state) => state.player_season_stats);
+  const { currentUser } = useAppSelector((state) => state.auth);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+  const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
+  const corners = useAppSelector((state) => state.style.corners);
+  const numPages =
+    Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
+  for (let i = 0; i < numPages; i++) {
+    pagesList.push(i);
+  }
+
+  const loadData = async (page = currentPage, request = filterRequest) => {
+    if (page !== currentPage) setCurrentPage(page);
+    if (request !== filterRequest) setFilterRequest(request);
+    const { sort, field } = sortModel[0];
+
+    const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
+    dispatch(fetch({ limit: perPage, page, query }));
+  };
+
+  useEffect(() => {
+    if (player_season_statsNotify.showNotification) {
+      notify(
+        player_season_statsNotify.typeNotification,
+        player_season_statsNotify.textNotification,
+      );
+    }
+  }, [player_season_statsNotify.showNotification]);
+
+  useEffect(() => {
+    if (!currentUser) return;
+    loadData();
+  }, [sortModel, currentUser]);
+
+  useEffect(() => {
+    if (refetch) {
+      loadData(0);
+      dispatch(setRefetch(false));
+    }
+  }, [refetch, dispatch]);
+
+  const [isModalInfoActive, setIsModalInfoActive] = useState(false);
+  const [isModalTrashActive, setIsModalTrashActive] = useState(false);
+
+  const handleModalAction = () => {
+    setIsModalInfoActive(false);
+    setIsModalTrashActive(false);
+  };
+
+  const handleDeleteModalAction = (id: string) => {
+    setId(id);
+    setIsModalTrashActive(true);
+  };
+  const handleDeleteAction = async () => {
+    if (id) {
+      await dispatch(deleteItem(id));
+      await loadData(0);
+      setIsModalTrashActive(false);
+    }
+  };
+
+  const generateFilterRequests = useMemo(() => {
+    let request = '&';
+    filterItems.forEach((item) => {
+      const isRangeFilter = filters.find(
+        (filter) =>
+          filter.title === item.fields.selectedField &&
+          (filter.number || filter.date),
+      );
+
+      if (isRangeFilter) {
+        const from = item.fields.filterValueFrom;
+        const to = item.fields.filterValueTo;
+        if (from) {
+          request += `${item.fields.selectedField}Range=${from}&`;
+        }
+        if (to) {
+          request += `${item.fields.selectedField}Range=${to}&`;
+        }
+      } else {
+        const value = item.fields.filterValue;
+        if (value) {
+          request += `${item.fields.selectedField}=${value}&`;
+        }
+      }
+    });
+    return request;
+  }, [filterItems, filters]);
+
+  const deleteFilter = (value) => {
+    const newItems = filterItems.filter((item) => item.id !== value);
+
+    if (newItems.length) {
+      setFilterItems(newItems);
+    } else {
+      loadData(0, '');
+
+      setFilterItems(newItems);
+    }
+  };
+
+  const handleSubmit = () => {
+    loadData(0, generateFilterRequests);
+  };
+
+  const handleChange = (id) => (e) => {
+    const value = e.target.value;
+    const name = e.target.name;
+
+    setFilterItems(
+      filterItems.map((item) => {
+        if (item.id !== id) return item;
+        if (name === 'selectedField') return { id, fields: { [name]: value } };
+
+        return { id, fields: { ...item.fields, [name]: value } };
+      }),
+    );
+  };
+
+  const handleReset = () => {
+    setFilterItems([]);
+    loadData(0, '');
+  };
+
+  const onPageChange = (page: number) => {
+    loadData(page);
+    setCurrentPage(page);
+  };
+
+  useEffect(() => {
+    if (!currentUser) return;
+
+    loadColumns(
+      handleDeleteModalAction,
+      `player_season_stats`,
+      currentUser,
+    ).then((newCols) => setColumns(newCols));
+  }, [currentUser]);
+
+  const handleTableSubmit = async (id: string, data) => {
+    if (!_.isEmpty(data)) {
+      await dispatch(update({ id, data }))
+        .unwrap()
+        .then((res) => res)
+        .catch((err) => {
+          throw new Error(err);
+        });
+    }
+  };
+
+  const onDeleteRows = async (selectedRows) => {
+    await dispatch(deleteItemsByIds(selectedRows));
+    await loadData(0);
+  };
+
+  const controlClasses =
+    'w-full py-2 px-2 my-2   rounded dark:placeholder-gray-400 ' +
+    ` ${bgColor} ${focusRing} ${corners} ` +
+    'dark:bg-slate-800 border';
+
+  const dataGrid = (
+    <div className='relative overflow-x-auto'>
+      <DataGrid
+        autoHeight
+        rowHeight={64}
+        sx={dataGridStyles}
+        className={'datagrid--table'}
+        getRowClassName={() => `datagrid--row`}
+        rows={player_season_stats ?? []}
+        columns={columns}
+        initialState={{
+          pagination: {
+            paginationModel: {
+              pageSize: 10,
+            },
+          },
+        }}
+        disableRowSelectionOnClick
+        onProcessRowUpdateError={(params) => {
+          console.log('Error', params);
+        }}
+        processRowUpdate={async (newRow, oldRow) => {
+          const data = dataFormatter.dataGridEditFormatter(newRow);
+
+          try {
+            await handleTableSubmit(newRow.id, data);
+            return newRow;
+          } catch {
+            return oldRow;
+          }
+        }}
+        sortingMode={'server'}
+        checkboxSelection
+        onRowSelectionModelChange={(ids) => {
+          setSelectedRows(ids);
+        }}
+        onSortModelChange={(params) => {
+          params.length
+            ? setSortModel(params)
+            : setSortModel([{ field: '', sort: 'desc' }]);
+        }}
+        rowCount={count}
+        pageSizeOptions={[10]}
+        paginationMode={'server'}
+        loading={loading}
+        onPaginationModelChange={(params) => {
+          onPageChange(params.page);
+        }}
+      />
+    </div>
+  );
+
+  return (
+    <>
+      {filterItems && Array.isArray(filterItems) && filterItems.length ? (
+        <CardBox>
+          <Formik
+            initialValues={{
+              checkboxes: ['lorem'],
+              switches: ['lorem'],
+              radio: 'lorem',
+            }}
+            onSubmit={() => null}
+          >
+            <Form>
+              <>
+                {filterItems &&
+                  filterItems.map((filterItem) => {
+                    return (
+                      <div key={filterItem.id} className='flex mb-4'>
+                        <div className='flex flex-col w-full mr-3'>
+                          <div className='  text-gray-500  font-bold'>
+                            Filter
+                          </div>
+                          <Field
+                            className={controlClasses}
+                            name='selectedField'
+                            id='selectedField'
+                            component='select'
+                            value={filterItem?.fields?.selectedField || ''}
+                            onChange={handleChange(filterItem.id)}
+                          >
+                            {filters.map((selectOption) => (
+                              <option
+                                key={selectOption.title}
+                                value={`${selectOption.title}`}
+                              >
+                                {selectOption.label}
+                              </option>
+                            ))}
+                          </Field>
+                        </div>
+                        {filters.find(
+                          (filter) =>
+                            filter.title === filterItem?.fields?.selectedField,
+                        )?.type === 'enum' ? (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='text-gray-500 font-bold'>Value</div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              id='filterValue'
+                              component='select'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            >
+                              <option value=''>Select Value</option>
+                              {filters
+                                .find(
+                                  (filter) =>
+                                    filter.title ===
+                                    filterItem?.fields?.selectedField,
+                                )
+                                ?.options?.map((option) => (
+                                  <option key={option} value={option}>
+                                    {option}
+                                  </option>
+                                ))}
+                            </Field>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.number ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.date ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                type='datetime-local'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                type='datetime-local'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='  text-gray-500  font-bold'>
+                              Contains
+                            </div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              placeholder='Contained'
+                              id='filterValue'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            />
+                          </div>
+                        )}
+                        <div className='flex flex-col'>
+                          <div className='  text-gray-500  font-bold'>
+                            Action
+                          </div>
+                          <BaseButton
+                            className='my-2'
+                            type='reset'
+                            color='danger'
+                            label='Delete'
+                            onClick={() => {
+                              deleteFilter(filterItem.id);
+                            }}
+                          />
+                        </div>
+                      </div>
+                    );
+                  })}
+                <div className='flex'>
+                  <BaseButton
+                    className='my-2 mr-3'
+                    color='success'
+                    label='Apply'
+                    onClick={handleSubmit}
+                  />
+                  <BaseButton
+                    className='my-2'
+                    color='info'
+                    label='Cancel'
+                    onClick={handleReset}
+                  />
+                </div>
+              </>
+            </Form>
+          </Formik>
+        </CardBox>
+      ) : null}
+      <CardBoxModal
+        title='Please confirm'
+        buttonColor='info'
+        buttonLabel={loading ? 'Deleting...' : 'Confirm'}
+        isActive={isModalTrashActive}
+        onConfirm={handleDeleteAction}
+        onCancel={handleModalAction}
+      >
+        <p>Are you sure you want to delete this item?</p>
+      </CardBoxModal>
+
+      {dataGrid}
+
+      {selectedRows.length > 0 &&
+        createPortal(
+          <BaseButton
+            className='me-4'
+            color='danger'
+            label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
+            onClick={() => onDeleteRows(selectedRows)}
+          />,
+          document.getElementById('delete-rows-button'),
+        )}
+      <ToastContainer />
+    </>
+  );
+};
+
+export default TableSamplePlayer_season_stats;

frontend/src/components/Player_season_stats/configurePlayer_season_statsCols.tsx

@@ -0,0 +1,172 @@
+import React from 'react';
+import BaseIcon from '../BaseIcon';
+import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
+import axios from 'axios';
+import {
+  GridActionsCellItem,
+  GridRowParams,
+  GridValueGetterParams,
+} from '@mui/x-data-grid';
+import ImageField from '../ImageField';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import DataGridMultiSelect from '../DataGridMultiSelect';
+import ListActionsPopover from '../ListActionsPopover';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Params = (id: string) => void;
+
+export const loadColumns = async (
+  onDelete: Params,
+  entityName: string,
+
+  user,
+) => {
+  async function callOptionsApi(entityName: string) {
+    if (!hasPermission(user, 'READ_' + entityName.toUpperCase())) return [];
+
+    try {
+      const data = await axios(`/${entityName}/autocomplete?limit=100`);
+      return data.data;
+    } catch (error) {
+      console.log(error);
+      return [];
+    }
+  }
+
+  const hasUpdatePermission = hasPermission(user, 'UPDATE_PLAYER_SEASON_STATS');
+
+  return [
+    {
+      field: 'player',
+      headerName: 'Player',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('players'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'season',
+      headerName: 'Season',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('seasons'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'totalpoints',
+      headerName: 'Totalpoints',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'number',
+    },
+
+    {
+      field: 'gamesplayed',
+      headerName: 'Gamesplayed',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'number',
+    },
+
+    {
+      field: 'eightballruns',
+      headerName: 'Eightballruns',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'number',
+    },
+
+    {
+      field: 'eightballbreaks',
+      headerName: 'Eightballbreaks',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'number',
+    },
+
+    {
+      field: 'nineballruns',
+      headerName: 'Nineballruns',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'number',
+    },
+
+    {
+      field: 'actions',
+      type: 'actions',
+      minWidth: 30,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+      getActions: (params: GridRowParams) => {
+        return [
+          <div key={params?.row?.id}>
+            <ListActionsPopover
+              onDelete={onDelete}
+              itemId={params?.row?.id}
+              pathEdit={`/player_season_stats/player_season_stats-edit/?id=${params?.row?.id}`}
+              pathView={`/player_season_stats/player_season_stats-view/?id=${params?.row?.id}`}
+              hasUpdatePermission={hasUpdatePermission}
+            />
+          </div>,
+        ];
+      },
+    },
+  ];
+};

frontend/src/components/Seasons/CardSeasons.tsx

@@ -0,0 +1,138 @@
+import React from 'react';
+import ImageField from '../ImageField';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import dataFormatter from '../../helpers/dataFormatter';
+import { Pagination } from '../Pagination';
+import { saveFile } from '../../helpers/fileSaver';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  seasons: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const CardSeasons = ({
+  seasons,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const asideScrollbarsStyle = useAppSelector(
+    (state) => state.style.asideScrollbarsStyle,
+  );
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+  const darkMode = useAppSelector((state) => state.style.darkMode);
+  const corners = useAppSelector((state) => state.style.corners);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(currentUser, 'UPDATE_SEASONS');
+
+  return (
+    <div className={'p-4'}>
+      {loading && <LoadingSpinner />}
+      <ul
+        role='list'
+        className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
+      >
+        {!loading &&
+          seasons.map((item, index) => (
+            <li
+              key={item.id}
+              className={`overflow-hidden ${
+                corners !== 'rounded-full' ? corners : 'rounded-3xl'
+              } border  ${focusRing} border-gray-200 dark:border-dark-700 ${
+                darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
+              }`}
+            >
+              <div
+                className={`flex items-center ${bgColor} p-6  gap-x-4 border-b border-gray-900/5 bg-gray-50 dark:bg-dark-800 relative`}
+              >
+                <Link
+                  href={`/seasons/seasons-view/?id=${item.id}`}
+                  className='text-lg font-bold leading-6 line-clamp-1'
+                >
+                  {item.name}
+                </Link>
+
+                <div className='ml-auto '>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/seasons/seasons-edit/?id=${item.id}`}
+                    pathView={`/seasons/seasons-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </div>
+              <dl className='divide-y  divide-stone-300   dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>Name</dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>{item.name}</div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Startdate
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.dateFormatter(item.startdate)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Enddate
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.dateFormatter(item.enddate)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    League
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.leaguesOneListFormatter(item.league)}
+                    </div>
+                  </dd>
+                </div>
+              </dl>
+            </li>
+          ))}
+        {!loading && seasons.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </ul>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </div>
+  );
+};
+
+export default CardSeasons;

frontend/src/components/Seasons/ListSeasons.tsx

@@ -0,0 +1,108 @@
+import React from 'react';
+import CardBox from '../CardBox';
+import ImageField from '../ImageField';
+import dataFormatter from '../../helpers/dataFormatter';
+import { saveFile } from '../../helpers/fileSaver';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import { Pagination } from '../Pagination';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  seasons: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const ListSeasons = ({
+  seasons,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(currentUser, 'UPDATE_SEASONS');
+
+  const corners = useAppSelector((state) => state.style.corners);
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+
+  return (
+    <>
+      <div className='relative overflow-x-auto p-4 space-y-4'>
+        {loading && <LoadingSpinner />}
+        {!loading &&
+          seasons.map((item) => (
+            <div key={item.id}>
+              <CardBox hasTable isList className={'rounded shadow-none'}>
+                <div
+                  className={`flex rounded  dark:bg-dark-900  border  border-stone-300  items-center overflow-hidden`}
+                >
+                  <Link
+                    href={`/seasons/seasons-view/?id=${item.id}`}
+                    className={
+                      'flex-1 px-4 py-6 h-24 flex divide-x-2  divide-stone-300   items-center overflow-hidden`}> dark:divide-dark-700 overflow-x-auto'
+                    }
+                  >
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Name</p>
+                      <p className={'line-clamp-2'}>{item.name}</p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Startdate</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.dateFormatter(item.startdate)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Enddate</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.dateFormatter(item.enddate)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>League</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.leaguesOneListFormatter(item.league)}
+                      </p>
+                    </div>
+                  </Link>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/seasons/seasons-edit/?id=${item.id}`}
+                    pathView={`/seasons/seasons-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </CardBox>
+            </div>
+          ))}
+        {!loading && seasons.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </div>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </>
+  );
+};
+
+export default ListSeasons;

frontend/src/components/Seasons/TableSeasons.tsx

@@ -0,0 +1,481 @@
+import React, { useEffect, useState, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import { ToastContainer, toast } from 'react-toastify';
+import BaseButton from '../BaseButton';
+import CardBoxModal from '../CardBoxModal';
+import CardBox from '../CardBox';
+import {
+  fetch,
+  update,
+  deleteItem,
+  setRefetch,
+  deleteItemsByIds,
+} from '../../stores/seasons/seasonsSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { Field, Form, Formik } from 'formik';
+import { DataGrid, GridColDef } from '@mui/x-data-grid';
+import { loadColumns } from './configureSeasonsCols';
+import _ from 'lodash';
+import dataFormatter from '../../helpers/dataFormatter';
+import { dataGridStyles } from '../../styles';
+
+const perPage = 10;
+
+const TableSampleSeasons = ({
+  filterItems,
+  setFilterItems,
+  filters,
+  showGrid,
+}) => {
+  const notify = (type, msg) => toast(msg, { type, position: 'bottom-center' });
+
+  const dispatch = useAppDispatch();
+  const router = useRouter();
+
+  const pagesList = [];
+  const [id, setId] = useState(null);
+  const [currentPage, setCurrentPage] = useState(0);
+  const [filterRequest, setFilterRequest] = React.useState('');
+  const [columns, setColumns] = useState<GridColDef[]>([]);
+  const [selectedRows, setSelectedRows] = useState([]);
+  const [sortModel, setSortModel] = useState([
+    {
+      field: '',
+      sort: 'desc',
+    },
+  ]);
+
+  const {
+    seasons,
+    loading,
+    count,
+    notify: seasonsNotify,
+    refetch,
+  } = useAppSelector((state) => state.seasons);
+  const { currentUser } = useAppSelector((state) => state.auth);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+  const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
+  const corners = useAppSelector((state) => state.style.corners);
+  const numPages =
+    Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
+  for (let i = 0; i < numPages; i++) {
+    pagesList.push(i);
+  }
+
+  const loadData = async (page = currentPage, request = filterRequest) => {
+    if (page !== currentPage) setCurrentPage(page);
+    if (request !== filterRequest) setFilterRequest(request);
+    const { sort, field } = sortModel[0];
+
+    const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
+    dispatch(fetch({ limit: perPage, page, query }));
+  };
+
+  useEffect(() => {
+    if (seasonsNotify.showNotification) {
+      notify(seasonsNotify.typeNotification, seasonsNotify.textNotification);
+    }
+  }, [seasonsNotify.showNotification]);
+
+  useEffect(() => {
+    if (!currentUser) return;
+    loadData();
+  }, [sortModel, currentUser]);
+
+  useEffect(() => {
+    if (refetch) {
+      loadData(0);
+      dispatch(setRefetch(false));
+    }
+  }, [refetch, dispatch]);
+
+  const [isModalInfoActive, setIsModalInfoActive] = useState(false);
+  const [isModalTrashActive, setIsModalTrashActive] = useState(false);
+
+  const handleModalAction = () => {
+    setIsModalInfoActive(false);
+    setIsModalTrashActive(false);
+  };
+
+  const handleDeleteModalAction = (id: string) => {
+    setId(id);
+    setIsModalTrashActive(true);
+  };
+  const handleDeleteAction = async () => {
+    if (id) {
+      await dispatch(deleteItem(id));
+      await loadData(0);
+      setIsModalTrashActive(false);
+    }
+  };
+
+  const generateFilterRequests = useMemo(() => {
+    let request = '&';
+    filterItems.forEach((item) => {
+      const isRangeFilter = filters.find(
+        (filter) =>
+          filter.title === item.fields.selectedField &&
+          (filter.number || filter.date),
+      );
+
+      if (isRangeFilter) {
+        const from = item.fields.filterValueFrom;
+        const to = item.fields.filterValueTo;
+        if (from) {
+          request += `${item.fields.selectedField}Range=${from}&`;
+        }
+        if (to) {
+          request += `${item.fields.selectedField}Range=${to}&`;
+        }
+      } else {
+        const value = item.fields.filterValue;
+        if (value) {
+          request += `${item.fields.selectedField}=${value}&`;
+        }
+      }
+    });
+    return request;
+  }, [filterItems, filters]);
+
+  const deleteFilter = (value) => {
+    const newItems = filterItems.filter((item) => item.id !== value);
+
+    if (newItems.length) {
+      setFilterItems(newItems);
+    } else {
+      loadData(0, '');
+
+      setFilterItems(newItems);
+    }
+  };
+
+  const handleSubmit = () => {
+    loadData(0, generateFilterRequests);
+  };
+
+  const handleChange = (id) => (e) => {
+    const value = e.target.value;
+    const name = e.target.name;
+
+    setFilterItems(
+      filterItems.map((item) => {
+        if (item.id !== id) return item;
+        if (name === 'selectedField') return { id, fields: { [name]: value } };
+
+        return { id, fields: { ...item.fields, [name]: value } };
+      }),
+    );
+  };
+
+  const handleReset = () => {
+    setFilterItems([]);
+    loadData(0, '');
+  };
+
+  const onPageChange = (page: number) => {
+    loadData(page);
+    setCurrentPage(page);
+  };
+
+  useEffect(() => {
+    if (!currentUser) return;
+
+    loadColumns(handleDeleteModalAction, `seasons`, currentUser).then(
+      (newCols) => setColumns(newCols),
+    );
+  }, [currentUser]);
+
+  const handleTableSubmit = async (id: string, data) => {
+    if (!_.isEmpty(data)) {
+      await dispatch(update({ id, data }))
+        .unwrap()
+        .then((res) => res)
+        .catch((err) => {
+          throw new Error(err);
+        });
+    }
+  };
+
+  const onDeleteRows = async (selectedRows) => {
+    await dispatch(deleteItemsByIds(selectedRows));
+    await loadData(0);
+  };
+
+  const controlClasses =
+    'w-full py-2 px-2 my-2   rounded dark:placeholder-gray-400 ' +
+    ` ${bgColor} ${focusRing} ${corners} ` +
+    'dark:bg-slate-800 border';
+
+  const dataGrid = (
+    <div className='relative overflow-x-auto'>
+      <DataGrid
+        autoHeight
+        rowHeight={64}
+        sx={dataGridStyles}
+        className={'datagrid--table'}
+        getRowClassName={() => `datagrid--row`}
+        rows={seasons ?? []}
+        columns={columns}
+        initialState={{
+          pagination: {
+            paginationModel: {
+              pageSize: 10,
+            },
+          },
+        }}
+        disableRowSelectionOnClick
+        onProcessRowUpdateError={(params) => {
+          console.log('Error', params);
+        }}
+        processRowUpdate={async (newRow, oldRow) => {
+          const data = dataFormatter.dataGridEditFormatter(newRow);
+
+          try {
+            await handleTableSubmit(newRow.id, data);
+            return newRow;
+          } catch {
+            return oldRow;
+          }
+        }}
+        sortingMode={'server'}
+        checkboxSelection
+        onRowSelectionModelChange={(ids) => {
+          setSelectedRows(ids);
+        }}
+        onSortModelChange={(params) => {
+          params.length
+            ? setSortModel(params)
+            : setSortModel([{ field: '', sort: 'desc' }]);
+        }}
+        rowCount={count}
+        pageSizeOptions={[10]}
+        paginationMode={'server'}
+        loading={loading}
+        onPaginationModelChange={(params) => {
+          onPageChange(params.page);
+        }}
+      />
+    </div>
+  );
+
+  return (
+    <>
+      {filterItems && Array.isArray(filterItems) && filterItems.length ? (
+        <CardBox>
+          <Formik
+            initialValues={{
+              checkboxes: ['lorem'],
+              switches: ['lorem'],
+              radio: 'lorem',
+            }}
+            onSubmit={() => null}
+          >
+            <Form>
+              <>
+                {filterItems &&
+                  filterItems.map((filterItem) => {
+                    return (
+                      <div key={filterItem.id} className='flex mb-4'>
+                        <div className='flex flex-col w-full mr-3'>
+                          <div className='  text-gray-500  font-bold'>
+                            Filter
+                          </div>
+                          <Field
+                            className={controlClasses}
+                            name='selectedField'
+                            id='selectedField'
+                            component='select'
+                            value={filterItem?.fields?.selectedField || ''}
+                            onChange={handleChange(filterItem.id)}
+                          >
+                            {filters.map((selectOption) => (
+                              <option
+                                key={selectOption.title}
+                                value={`${selectOption.title}`}
+                              >
+                                {selectOption.label}
+                              </option>
+                            ))}
+                          </Field>
+                        </div>
+                        {filters.find(
+                          (filter) =>
+                            filter.title === filterItem?.fields?.selectedField,
+                        )?.type === 'enum' ? (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='text-gray-500 font-bold'>Value</div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              id='filterValue'
+                              component='select'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            >
+                              <option value=''>Select Value</option>
+                              {filters
+                                .find(
+                                  (filter) =>
+                                    filter.title ===
+                                    filterItem?.fields?.selectedField,
+                                )
+                                ?.options?.map((option) => (
+                                  <option key={option} value={option}>
+                                    {option}
+                                  </option>
+                                ))}
+                            </Field>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.number ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.date ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                type='datetime-local'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                type='datetime-local'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='  text-gray-500  font-bold'>
+                              Contains
+                            </div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              placeholder='Contained'
+                              id='filterValue'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            />
+                          </div>
+                        )}
+                        <div className='flex flex-col'>
+                          <div className='  text-gray-500  font-bold'>
+                            Action
+                          </div>
+                          <BaseButton
+                            className='my-2'
+                            type='reset'
+                            color='danger'
+                            label='Delete'
+                            onClick={() => {
+                              deleteFilter(filterItem.id);
+                            }}
+                          />
+                        </div>
+                      </div>
+                    );
+                  })}
+                <div className='flex'>
+                  <BaseButton
+                    className='my-2 mr-3'
+                    color='success'
+                    label='Apply'
+                    onClick={handleSubmit}
+                  />
+                  <BaseButton
+                    className='my-2'
+                    color='info'
+                    label='Cancel'
+                    onClick={handleReset}
+                  />
+                </div>
+              </>
+            </Form>
+          </Formik>
+        </CardBox>
+      ) : null}
+      <CardBoxModal
+        title='Please confirm'
+        buttonColor='info'
+        buttonLabel={loading ? 'Deleting...' : 'Confirm'}
+        isActive={isModalTrashActive}
+        onConfirm={handleDeleteAction}
+        onCancel={handleModalAction}
+      >
+        <p>Are you sure you want to delete this item?</p>
+      </CardBoxModal>
+
+      {dataGrid}
+
+      {selectedRows.length > 0 &&
+        createPortal(
+          <BaseButton
+            className='me-4'
+            color='danger'
+            label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
+            onClick={() => onDeleteRows(selectedRows)}
+          />,
+          document.getElementById('delete-rows-button'),
+        )}
+      <ToastContainer />
+    </>
+  );
+};
+
+export default TableSampleSeasons;

frontend/src/components/Seasons/configureSeasonsCols.tsx

@@ -0,0 +1,126 @@
+import React from 'react';
+import BaseIcon from '../BaseIcon';
+import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
+import axios from 'axios';
+import {
+  GridActionsCellItem,
+  GridRowParams,
+  GridValueGetterParams,
+} from '@mui/x-data-grid';
+import ImageField from '../ImageField';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import DataGridMultiSelect from '../DataGridMultiSelect';
+import ListActionsPopover from '../ListActionsPopover';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Params = (id: string) => void;
+
+export const loadColumns = async (
+  onDelete: Params,
+  entityName: string,
+
+  user,
+) => {
+  async function callOptionsApi(entityName: string) {
+    if (!hasPermission(user, 'READ_' + entityName.toUpperCase())) return [];
+
+    try {
+      const data = await axios(`/${entityName}/autocomplete?limit=100`);
+      return data.data;
+    } catch (error) {
+      console.log(error);
+      return [];
+    }
+  }
+
+  const hasUpdatePermission = hasPermission(user, 'UPDATE_SEASONS');
+
+  return [
+    {
+      field: 'name',
+      headerName: 'Name',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+    },
+
+    {
+      field: 'startdate',
+      headerName: 'Startdate',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'date',
+      valueGetter: (params: GridValueGetterParams) =>
+        new Date(params.row.startdate),
+    },
+
+    {
+      field: 'enddate',
+      headerName: 'Enddate',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      type: 'date',
+      valueGetter: (params: GridValueGetterParams) =>
+        new Date(params.row.enddate),
+    },
+
+    {
+      field: 'league',
+      headerName: 'League',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('leagues'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'actions',
+      type: 'actions',
+      minWidth: 30,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+      getActions: (params: GridRowParams) => {
+        return [
+          <div key={params?.row?.id}>
+            <ListActionsPopover
+              onDelete={onDelete}
+              itemId={params?.row?.id}
+              pathEdit={`/seasons/seasons-edit/?id=${params?.row?.id}`}
+              pathView={`/seasons/seasons-view/?id=${params?.row?.id}`}
+              hasUpdatePermission={hasUpdatePermission}
+            />
+          </div>,
+        ];
+      },
+    },
+  ];
+};

frontend/src/components/Team_season_stats/CardTeam_season_stats.tsx

@@ -0,0 +1,121 @@
+import React from 'react';
+import ImageField from '../ImageField';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import dataFormatter from '../../helpers/dataFormatter';
+import { Pagination } from '../Pagination';
+import { saveFile } from '../../helpers/fileSaver';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  team_season_stats: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const CardTeam_season_stats = ({
+  team_season_stats,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const asideScrollbarsStyle = useAppSelector(
+    (state) => state.style.asideScrollbarsStyle,
+  );
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+  const darkMode = useAppSelector((state) => state.style.darkMode);
+  const corners = useAppSelector((state) => state.style.corners);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_TEAM_SEASON_STATS',
+  );
+
+  return (
+    <div className={'p-4'}>
+      {loading && <LoadingSpinner />}
+      <ul
+        role='list'
+        className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
+      >
+        {!loading &&
+          team_season_stats.map((item, index) => (
+            <li
+              key={item.id}
+              className={`overflow-hidden ${
+                corners !== 'rounded-full' ? corners : 'rounded-3xl'
+              } border  ${focusRing} border-gray-200 dark:border-dark-700 ${
+                darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
+              }`}
+            >
+              <div
+                className={`flex items-center ${bgColor} p-6  gap-x-4 border-b border-gray-900/5 bg-gray-50 dark:bg-dark-800 relative`}
+              >
+                <Link
+                  href={`/team_season_stats/team_season_stats-view/?id=${item.id}`}
+                  className='text-lg font-bold leading-6 line-clamp-1'
+                >
+                  {item.id}
+                </Link>
+
+                <div className='ml-auto '>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/team_season_stats/team_season_stats-edit/?id=${item.id}`}
+                    pathView={`/team_season_stats/team_season_stats-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </div>
+              <dl className='divide-y  divide-stone-300   dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>Team</dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.teamsOneListFormatter(item.team)}
+                    </div>
+                  </dd>
+                </div>
+
+                <div className='flex justify-between gap-x-4 py-3'>
+                  <dt className='  text-gray-500  dark:text-dark-600'>
+                    Season
+                  </dt>
+                  <dd className='flex items-start gap-x-2'>
+                    <div className='font-medium line-clamp-4'>
+                      {dataFormatter.seasonsOneListFormatter(item.season)}
+                    </div>
+                  </dd>
+                </div>
+              </dl>
+            </li>
+          ))}
+        {!loading && team_season_stats.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </ul>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </div>
+  );
+};
+
+export default CardTeam_season_stats;

frontend/src/components/Team_season_stats/ListTeam_season_stats.tsx

@@ -0,0 +1,99 @@
+import React from 'react';
+import CardBox from '../CardBox';
+import ImageField from '../ImageField';
+import dataFormatter from '../../helpers/dataFormatter';
+import { saveFile } from '../../helpers/fileSaver';
+import ListActionsPopover from '../ListActionsPopover';
+import { useAppSelector } from '../../stores/hooks';
+import { Pagination } from '../Pagination';
+import LoadingSpinner from '../LoadingSpinner';
+import Link from 'next/link';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Props = {
+  team_season_stats: any[];
+  loading: boolean;
+  onDelete: (id: string) => void;
+  currentPage: number;
+  numPages: number;
+  onPageChange: (page: number) => void;
+};
+
+const ListTeam_season_stats = ({
+  team_season_stats,
+  loading,
+  onDelete,
+  currentPage,
+  numPages,
+  onPageChange,
+}: Props) => {
+  const currentUser = useAppSelector((state) => state.auth.currentUser);
+  const hasUpdatePermission = hasPermission(
+    currentUser,
+    'UPDATE_TEAM_SEASON_STATS',
+  );
+
+  const corners = useAppSelector((state) => state.style.corners);
+  const bgColor = useAppSelector((state) => state.style.cardsColor);
+
+  return (
+    <>
+      <div className='relative overflow-x-auto p-4 space-y-4'>
+        {loading && <LoadingSpinner />}
+        {!loading &&
+          team_season_stats.map((item) => (
+            <div key={item.id}>
+              <CardBox hasTable isList className={'rounded shadow-none'}>
+                <div
+                  className={`flex rounded  dark:bg-dark-900  border  border-stone-300  items-center overflow-hidden`}
+                >
+                  <Link
+                    href={`/team_season_stats/team_season_stats-view/?id=${item.id}`}
+                    className={
+                      'flex-1 px-4 py-6 h-24 flex divide-x-2  divide-stone-300   items-center overflow-hidden`}> dark:divide-dark-700 overflow-x-auto'
+                    }
+                  >
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Team</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.teamsOneListFormatter(item.team)}
+                      </p>
+                    </div>
+
+                    <div className={'flex-1 px-3'}>
+                      <p className={'text-xs   text-gray-500 '}>Season</p>
+                      <p className={'line-clamp-2'}>
+                        {dataFormatter.seasonsOneListFormatter(item.season)}
+                      </p>
+                    </div>
+                  </Link>
+                  <ListActionsPopover
+                    onDelete={onDelete}
+                    itemId={item.id}
+                    pathEdit={`/team_season_stats/team_season_stats-edit/?id=${item.id}`}
+                    pathView={`/team_season_stats/team_season_stats-view/?id=${item.id}`}
+                    hasUpdatePermission={hasUpdatePermission}
+                  />
+                </div>
+              </CardBox>
+            </div>
+          ))}
+        {!loading && team_season_stats.length === 0 && (
+          <div className='col-span-full flex items-center justify-center h-40'>
+            <p className=''>No data to display</p>
+          </div>
+        )}
+      </div>
+      <div className={'flex items-center justify-center my-6'}>
+        <Pagination
+          currentPage={currentPage}
+          numPages={numPages}
+          setCurrentPage={onPageChange}
+        />
+      </div>
+    </>
+  );
+};
+
+export default ListTeam_season_stats;

frontend/src/components/Team_season_stats/TableTeam_season_stats.tsx

@@ -0,0 +1,484 @@
+import React, { useEffect, useState, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import { ToastContainer, toast } from 'react-toastify';
+import BaseButton from '../BaseButton';
+import CardBoxModal from '../CardBoxModal';
+import CardBox from '../CardBox';
+import {
+  fetch,
+  update,
+  deleteItem,
+  setRefetch,
+  deleteItemsByIds,
+} from '../../stores/team_season_stats/team_season_statsSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { Field, Form, Formik } from 'formik';
+import { DataGrid, GridColDef } from '@mui/x-data-grid';
+import { loadColumns } from './configureTeam_season_statsCols';
+import _ from 'lodash';
+import dataFormatter from '../../helpers/dataFormatter';
+import { dataGridStyles } from '../../styles';
+
+const perPage = 10;
+
+const TableSampleTeam_season_stats = ({
+  filterItems,
+  setFilterItems,
+  filters,
+  showGrid,
+}) => {
+  const notify = (type, msg) => toast(msg, { type, position: 'bottom-center' });
+
+  const dispatch = useAppDispatch();
+  const router = useRouter();
+
+  const pagesList = [];
+  const [id, setId] = useState(null);
+  const [currentPage, setCurrentPage] = useState(0);
+  const [filterRequest, setFilterRequest] = React.useState('');
+  const [columns, setColumns] = useState<GridColDef[]>([]);
+  const [selectedRows, setSelectedRows] = useState([]);
+  const [sortModel, setSortModel] = useState([
+    {
+      field: '',
+      sort: 'desc',
+    },
+  ]);
+
+  const {
+    team_season_stats,
+    loading,
+    count,
+    notify: team_season_statsNotify,
+    refetch,
+  } = useAppSelector((state) => state.team_season_stats);
+  const { currentUser } = useAppSelector((state) => state.auth);
+  const focusRing = useAppSelector((state) => state.style.focusRingColor);
+  const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
+  const corners = useAppSelector((state) => state.style.corners);
+  const numPages =
+    Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
+  for (let i = 0; i < numPages; i++) {
+    pagesList.push(i);
+  }
+
+  const loadData = async (page = currentPage, request = filterRequest) => {
+    if (page !== currentPage) setCurrentPage(page);
+    if (request !== filterRequest) setFilterRequest(request);
+    const { sort, field } = sortModel[0];
+
+    const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
+    dispatch(fetch({ limit: perPage, page, query }));
+  };
+
+  useEffect(() => {
+    if (team_season_statsNotify.showNotification) {
+      notify(
+        team_season_statsNotify.typeNotification,
+        team_season_statsNotify.textNotification,
+      );
+    }
+  }, [team_season_statsNotify.showNotification]);
+
+  useEffect(() => {
+    if (!currentUser) return;
+    loadData();
+  }, [sortModel, currentUser]);
+
+  useEffect(() => {
+    if (refetch) {
+      loadData(0);
+      dispatch(setRefetch(false));
+    }
+  }, [refetch, dispatch]);
+
+  const [isModalInfoActive, setIsModalInfoActive] = useState(false);
+  const [isModalTrashActive, setIsModalTrashActive] = useState(false);
+
+  const handleModalAction = () => {
+    setIsModalInfoActive(false);
+    setIsModalTrashActive(false);
+  };
+
+  const handleDeleteModalAction = (id: string) => {
+    setId(id);
+    setIsModalTrashActive(true);
+  };
+  const handleDeleteAction = async () => {
+    if (id) {
+      await dispatch(deleteItem(id));
+      await loadData(0);
+      setIsModalTrashActive(false);
+    }
+  };
+
+  const generateFilterRequests = useMemo(() => {
+    let request = '&';
+    filterItems.forEach((item) => {
+      const isRangeFilter = filters.find(
+        (filter) =>
+          filter.title === item.fields.selectedField &&
+          (filter.number || filter.date),
+      );
+
+      if (isRangeFilter) {
+        const from = item.fields.filterValueFrom;
+        const to = item.fields.filterValueTo;
+        if (from) {
+          request += `${item.fields.selectedField}Range=${from}&`;
+        }
+        if (to) {
+          request += `${item.fields.selectedField}Range=${to}&`;
+        }
+      } else {
+        const value = item.fields.filterValue;
+        if (value) {
+          request += `${item.fields.selectedField}=${value}&`;
+        }
+      }
+    });
+    return request;
+  }, [filterItems, filters]);
+
+  const deleteFilter = (value) => {
+    const newItems = filterItems.filter((item) => item.id !== value);
+
+    if (newItems.length) {
+      setFilterItems(newItems);
+    } else {
+      loadData(0, '');
+
+      setFilterItems(newItems);
+    }
+  };
+
+  const handleSubmit = () => {
+    loadData(0, generateFilterRequests);
+  };
+
+  const handleChange = (id) => (e) => {
+    const value = e.target.value;
+    const name = e.target.name;
+
+    setFilterItems(
+      filterItems.map((item) => {
+        if (item.id !== id) return item;
+        if (name === 'selectedField') return { id, fields: { [name]: value } };
+
+        return { id, fields: { ...item.fields, [name]: value } };
+      }),
+    );
+  };
+
+  const handleReset = () => {
+    setFilterItems([]);
+    loadData(0, '');
+  };
+
+  const onPageChange = (page: number) => {
+    loadData(page);
+    setCurrentPage(page);
+  };
+
+  useEffect(() => {
+    if (!currentUser) return;
+
+    loadColumns(handleDeleteModalAction, `team_season_stats`, currentUser).then(
+      (newCols) => setColumns(newCols),
+    );
+  }, [currentUser]);
+
+  const handleTableSubmit = async (id: string, data) => {
+    if (!_.isEmpty(data)) {
+      await dispatch(update({ id, data }))
+        .unwrap()
+        .then((res) => res)
+        .catch((err) => {
+          throw new Error(err);
+        });
+    }
+  };
+
+  const onDeleteRows = async (selectedRows) => {
+    await dispatch(deleteItemsByIds(selectedRows));
+    await loadData(0);
+  };
+
+  const controlClasses =
+    'w-full py-2 px-2 my-2   rounded dark:placeholder-gray-400 ' +
+    ` ${bgColor} ${focusRing} ${corners} ` +
+    'dark:bg-slate-800 border';
+
+  const dataGrid = (
+    <div className='relative overflow-x-auto'>
+      <DataGrid
+        autoHeight
+        rowHeight={64}
+        sx={dataGridStyles}
+        className={'datagrid--table'}
+        getRowClassName={() => `datagrid--row`}
+        rows={team_season_stats ?? []}
+        columns={columns}
+        initialState={{
+          pagination: {
+            paginationModel: {
+              pageSize: 10,
+            },
+          },
+        }}
+        disableRowSelectionOnClick
+        onProcessRowUpdateError={(params) => {
+          console.log('Error', params);
+        }}
+        processRowUpdate={async (newRow, oldRow) => {
+          const data = dataFormatter.dataGridEditFormatter(newRow);
+
+          try {
+            await handleTableSubmit(newRow.id, data);
+            return newRow;
+          } catch {
+            return oldRow;
+          }
+        }}
+        sortingMode={'server'}
+        checkboxSelection
+        onRowSelectionModelChange={(ids) => {
+          setSelectedRows(ids);
+        }}
+        onSortModelChange={(params) => {
+          params.length
+            ? setSortModel(params)
+            : setSortModel([{ field: '', sort: 'desc' }]);
+        }}
+        rowCount={count}
+        pageSizeOptions={[10]}
+        paginationMode={'server'}
+        loading={loading}
+        onPaginationModelChange={(params) => {
+          onPageChange(params.page);
+        }}
+      />
+    </div>
+  );
+
+  return (
+    <>
+      {filterItems && Array.isArray(filterItems) && filterItems.length ? (
+        <CardBox>
+          <Formik
+            initialValues={{
+              checkboxes: ['lorem'],
+              switches: ['lorem'],
+              radio: 'lorem',
+            }}
+            onSubmit={() => null}
+          >
+            <Form>
+              <>
+                {filterItems &&
+                  filterItems.map((filterItem) => {
+                    return (
+                      <div key={filterItem.id} className='flex mb-4'>
+                        <div className='flex flex-col w-full mr-3'>
+                          <div className='  text-gray-500  font-bold'>
+                            Filter
+                          </div>
+                          <Field
+                            className={controlClasses}
+                            name='selectedField'
+                            id='selectedField'
+                            component='select'
+                            value={filterItem?.fields?.selectedField || ''}
+                            onChange={handleChange(filterItem.id)}
+                          >
+                            {filters.map((selectOption) => (
+                              <option
+                                key={selectOption.title}
+                                value={`${selectOption.title}`}
+                              >
+                                {selectOption.label}
+                              </option>
+                            ))}
+                          </Field>
+                        </div>
+                        {filters.find(
+                          (filter) =>
+                            filter.title === filterItem?.fields?.selectedField,
+                        )?.type === 'enum' ? (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='text-gray-500 font-bold'>Value</div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              id='filterValue'
+                              component='select'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            >
+                              <option value=''>Select Value</option>
+                              {filters
+                                .find(
+                                  (filter) =>
+                                    filter.title ===
+                                    filterItem?.fields?.selectedField,
+                                )
+                                ?.options?.map((option) => (
+                                  <option key={option} value={option}>
+                                    {option}
+                                  </option>
+                                ))}
+                            </Field>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.number ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : filters.find(
+                            (filter) =>
+                              filter.title ===
+                              filterItem?.fields?.selectedField,
+                          )?.date ? (
+                          <div className='flex flex-row w-full mr-3'>
+                            <div className='flex flex-col w-full mr-3'>
+                              <div className='  text-gray-500  font-bold'>
+                                From
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueFrom'
+                                placeholder='From'
+                                id='filterValueFrom'
+                                type='datetime-local'
+                                value={
+                                  filterItem?.fields?.filterValueFrom || ''
+                                }
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                            <div className='flex flex-col w-full'>
+                              <div className='  text-gray-500  font-bold'>
+                                To
+                              </div>
+                              <Field
+                                className={controlClasses}
+                                name='filterValueTo'
+                                placeholder='to'
+                                id='filterValueTo'
+                                type='datetime-local'
+                                value={filterItem?.fields?.filterValueTo || ''}
+                                onChange={handleChange(filterItem.id)}
+                              />
+                            </div>
+                          </div>
+                        ) : (
+                          <div className='flex flex-col w-full mr-3'>
+                            <div className='  text-gray-500  font-bold'>
+                              Contains
+                            </div>
+                            <Field
+                              className={controlClasses}
+                              name='filterValue'
+                              placeholder='Contained'
+                              id='filterValue'
+                              value={filterItem?.fields?.filterValue || ''}
+                              onChange={handleChange(filterItem.id)}
+                            />
+                          </div>
+                        )}
+                        <div className='flex flex-col'>
+                          <div className='  text-gray-500  font-bold'>
+                            Action
+                          </div>
+                          <BaseButton
+                            className='my-2'
+                            type='reset'
+                            color='danger'
+                            label='Delete'
+                            onClick={() => {
+                              deleteFilter(filterItem.id);
+                            }}
+                          />
+                        </div>
+                      </div>
+                    );
+                  })}
+                <div className='flex'>
+                  <BaseButton
+                    className='my-2 mr-3'
+                    color='success'
+                    label='Apply'
+                    onClick={handleSubmit}
+                  />
+                  <BaseButton
+                    className='my-2'
+                    color='info'
+                    label='Cancel'
+                    onClick={handleReset}
+                  />
+                </div>
+              </>
+            </Form>
+          </Formik>
+        </CardBox>
+      ) : null}
+      <CardBoxModal
+        title='Please confirm'
+        buttonColor='info'
+        buttonLabel={loading ? 'Deleting...' : 'Confirm'}
+        isActive={isModalTrashActive}
+        onConfirm={handleDeleteAction}
+        onCancel={handleModalAction}
+      >
+        <p>Are you sure you want to delete this item?</p>
+      </CardBoxModal>
+
+      {dataGrid}
+
+      {selectedRows.length > 0 &&
+        createPortal(
+          <BaseButton
+            className='me-4'
+            color='danger'
+            label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
+            onClick={() => onDeleteRows(selectedRows)}
+          />,
+          document.getElementById('delete-rows-button'),
+        )}
+      <ToastContainer />
+    </>
+  );
+};
+
+export default TableSampleTeam_season_stats;

frontend/src/components/Team_season_stats/configureTeam_season_statsCols.tsx

@@ -0,0 +1,102 @@
+import React from 'react';
+import BaseIcon from '../BaseIcon';
+import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
+import axios from 'axios';
+import {
+  GridActionsCellItem,
+  GridRowParams,
+  GridValueGetterParams,
+} from '@mui/x-data-grid';
+import ImageField from '../ImageField';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import DataGridMultiSelect from '../DataGridMultiSelect';
+import ListActionsPopover from '../ListActionsPopover';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+type Params = (id: string) => void;
+
+export const loadColumns = async (
+  onDelete: Params,
+  entityName: string,
+
+  user,
+) => {
+  async function callOptionsApi(entityName: string) {
+    if (!hasPermission(user, 'READ_' + entityName.toUpperCase())) return [];
+
+    try {
+      const data = await axios(`/${entityName}/autocomplete?limit=100`);
+      return data.data;
+    } catch (error) {
+      console.log(error);
+      return [];
+    }
+  }
+
+  const hasUpdatePermission = hasPermission(user, 'UPDATE_TEAM_SEASON_STATS');
+
+  return [
+    {
+      field: 'team',
+      headerName: 'Team',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('teams'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'season',
+      headerName: 'Season',
+      flex: 1,
+      minWidth: 120,
+      filterable: false,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+
+      editable: hasUpdatePermission,
+
+      sortable: false,
+      type: 'singleSelect',
+      getOptionValue: (value: any) => value?.id,
+      getOptionLabel: (value: any) => value?.label,
+      valueOptions: await callOptionsApi('seasons'),
+      valueGetter: (params: GridValueGetterParams) =>
+        params?.value?.id ?? params?.value,
+    },
+
+    {
+      field: 'actions',
+      type: 'actions',
+      minWidth: 30,
+      headerClassName: 'datagrid--header',
+      cellClassName: 'datagrid--cell',
+      getActions: (params: GridRowParams) => {
+        return [
+          <div key={params?.row?.id}>
+            <ListActionsPopover
+              onDelete={onDelete}
+              itemId={params?.row?.id}
+              pathEdit={`/team_season_stats/team_season_stats-edit/?id=${params?.row?.id}`}
+              pathView={`/team_season_stats/team_season_stats-view/?id=${params?.row?.id}`}
+              hasUpdatePermission={hasUpdatePermission}
+            />
+          </div>,
+        ];
+      },
+    },
+  ];
+};

frontend/src/components/WebPageComponents/Footer.tsx

@@ -19,7 +19,7 @@ export default function WebSiteFooter({ projectName }: WebSiteFooterProps) {
 
   const style = FooterStyle.WITH_PROJECT_NAME;
 
-  const design = FooterDesigns.DESIGN_DIVERSITY;
+  const design = FooterDesigns.DEFAULT_DESIGN;
 
   return (
     <div

frontend/src/components/WebPageComponents/Header.tsx

@@ -17,9 +17,9 @@ export default function WebSiteHeader({ projectName }: WebSiteHeaderProps) {
   const websiteHeder = useAppSelector((state) => state.style.websiteHeder);
   const borders = useAppSelector((state) => state.style.borders);
 
-  const style = HeaderStyle.PAGES_RIGHT;
+  const style = HeaderStyle.PAGES_LEFT;
 
-  const design = HeaderDesigns.DEFAULT_DESIGN;
+  const design = HeaderDesigns.DESIGN_DIVERSITY;
   return (
     <header id='websiteHeader' className='overflow-hidden'>
       <div

frontend/src/helpers/dataFormatter.js

@@ -58,6 +58,44 @@ export default {
     return { label: val.firstName, id: val.id };
   },
 
+  gamesManyListFormatter(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => item.date);
+  },
+  gamesOneListFormatter(val) {
+    if (!val) return '';
+    return val.date;
+  },
+  gamesManyListFormatterEdit(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => {
+      return { id: item.id, label: item.date };
+    });
+  },
+  gamesOneListFormatterEdit(val) {
+    if (!val) return '';
+    return { label: val.date, id: val.id };
+  },
+
+  playersManyListFormatter(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => item.first_name);
+  },
+  playersOneListFormatter(val) {
+    if (!val) return '';
+    return val.first_name;
+  },
+  playersManyListFormatterEdit(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => {
+      return { id: item.id, label: item.first_name };
+    });
+  },
+  playersOneListFormatterEdit(val) {
+    if (!val) return '';
+    return { label: val.first_name, id: val.id };
+  },
+
   teamsManyListFormatter(val) {
     if (!val || !val.length) return [];
     return val.map((item) => item.name);
@@ -133,4 +171,23 @@ export default {
     if (!val) return '';
     return { label: val.name, id: val.id };
   },
+
+  seasonsManyListFormatter(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => item.name);
+  },
+  seasonsOneListFormatter(val) {
+    if (!val) return '';
+    return val.name;
+  },
+  seasonsManyListFormatterEdit(val) {
+    if (!val || !val.length) return [];
+    return val.map((item) => {
+      return { id: item.id, label: item.name };
+    });
+  },
+  seasonsOneListFormatterEdit(val) {
+    if (!val) return '';
+    return { label: val.name, id: val.id };
+  },
 };

frontend/src/menuAside.ts

@@ -84,6 +84,38 @@ const menuAside: MenuAsideItem[] = [
     icon: icon.mdiTable ?? icon.mdiTable,
     permissions: 'READ_LEAGUES',
   },
+  {
+    href: '/seasons/seasons-list',
+    label: 'Seasons',
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    icon: icon.mdiTable ?? icon.mdiTable,
+    permissions: 'READ_SEASONS',
+  },
+  {
+    href: '/player_game_scores/player_game_scores-list',
+    label: 'Player game scores',
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    icon: icon.mdiTable ?? icon.mdiTable,
+    permissions: 'READ_PLAYER_GAME_SCORES',
+  },
+  {
+    href: '/player_season_stats/player_season_stats-list',
+    label: 'Player season stats',
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    icon: icon.mdiTable ?? icon.mdiTable,
+    permissions: 'READ_PLAYER_SEASON_STATS',
+  },
+  {
+    href: '/team_season_stats/team_season_stats-list',
+    label: 'Team season stats',
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    icon: icon.mdiTable ?? icon.mdiTable,
+    permissions: 'READ_TEAM_SEASON_STATS',
+  },
   {
     href: '/profile',
     label: 'Profile',

frontend/src/pages/dashboard.tsx

@@ -36,6 +36,13 @@ const Dashboard = () => {
   const [roles, setRoles] = React.useState(loadingMessage);
   const [permissions, setPermissions] = React.useState(loadingMessage);
   const [leagues, setLeagues] = React.useState(loadingMessage);
+  const [seasons, setSeasons] = React.useState(loadingMessage);
+  const [player_game_scores, setPlayer_game_scores] =
+    React.useState(loadingMessage);
+  const [player_season_stats, setPlayer_season_stats] =
+    React.useState(loadingMessage);
+  const [team_season_stats, setTeam_season_stats] =
+    React.useState(loadingMessage);
 
   const [widgetsRole, setWidgetsRole] = React.useState({
     role: { value: '', label: '' },
@@ -57,6 +64,10 @@ const Dashboard = () => {
       'roles',
       'permissions',
       'leagues',
+      'seasons',
+      'player_game_scores',
+      'player_season_stats',
+      'team_season_stats',
     ];
     const fns = [
       setUsers,
@@ -67,6 +78,10 @@ const Dashboard = () => {
       setRoles,
       setPermissions,
       setLeagues,
+      setSeasons,
+      setPlayer_game_scores,
+      setPlayer_season_stats,
+      setTeam_season_stats,
     ];
 
     const requests = entities.map((entity, index) => {
@@ -452,6 +467,134 @@ const Dashboard = () => {
               </div>
             </Link>
           )}
+
+          {hasPermission(currentUser, 'READ_SEASONS') && (
+            <Link href={'/seasons/seasons-list'}>
+              <div
+                className={`${
+                  corners !== 'rounded-full' ? corners : 'rounded-3xl'
+                } dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
+              >
+                <div className='flex justify-between align-center'>
+                  <div>
+                    <div className='text-lg leading-tight   text-gray-500 dark:text-gray-400'>
+                      Seasons
+                    </div>
+                    <div className='text-3xl leading-tight font-semibold'>
+                      {seasons}
+                    </div>
+                  </div>
+                  <div>
+                    <BaseIcon
+                      className={`${iconsColor}`}
+                      w='w-16'
+                      h='h-16'
+                      size={48}
+                      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                      // @ts-ignore
+                      path={icon.mdiTable || icon.mdiTable}
+                    />
+                  </div>
+                </div>
+              </div>
+            </Link>
+          )}
+
+          {hasPermission(currentUser, 'READ_PLAYER_GAME_SCORES') && (
+            <Link href={'/player_game_scores/player_game_scores-list'}>
+              <div
+                className={`${
+                  corners !== 'rounded-full' ? corners : 'rounded-3xl'
+                } dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
+              >
+                <div className='flex justify-between align-center'>
+                  <div>
+                    <div className='text-lg leading-tight   text-gray-500 dark:text-gray-400'>
+                      Player game scores
+                    </div>
+                    <div className='text-3xl leading-tight font-semibold'>
+                      {player_game_scores}
+                    </div>
+                  </div>
+                  <div>
+                    <BaseIcon
+                      className={`${iconsColor}`}
+                      w='w-16'
+                      h='h-16'
+                      size={48}
+                      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                      // @ts-ignore
+                      path={icon.mdiTable || icon.mdiTable}
+                    />
+                  </div>
+                </div>
+              </div>
+            </Link>
+          )}
+
+          {hasPermission(currentUser, 'READ_PLAYER_SEASON_STATS') && (
+            <Link href={'/player_season_stats/player_season_stats-list'}>
+              <div
+                className={`${
+                  corners !== 'rounded-full' ? corners : 'rounded-3xl'
+                } dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
+              >
+                <div className='flex justify-between align-center'>
+                  <div>
+                    <div className='text-lg leading-tight   text-gray-500 dark:text-gray-400'>
+                      Player season stats
+                    </div>
+                    <div className='text-3xl leading-tight font-semibold'>
+                      {player_season_stats}
+                    </div>
+                  </div>
+                  <div>
+                    <BaseIcon
+                      className={`${iconsColor}`}
+                      w='w-16'
+                      h='h-16'
+                      size={48}
+                      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                      // @ts-ignore
+                      path={icon.mdiTable || icon.mdiTable}
+                    />
+                  </div>
+                </div>
+              </div>
+            </Link>
+          )}
+
+          {hasPermission(currentUser, 'READ_TEAM_SEASON_STATS') && (
+            <Link href={'/team_season_stats/team_season_stats-list'}>
+              <div
+                className={`${
+                  corners !== 'rounded-full' ? corners : 'rounded-3xl'
+                } dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
+              >
+                <div className='flex justify-between align-center'>
+                  <div>
+                    <div className='text-lg leading-tight   text-gray-500 dark:text-gray-400'>
+                      Team season stats
+                    </div>
+                    <div className='text-3xl leading-tight font-semibold'>
+                      {team_season_stats}
+                    </div>
+                  </div>
+                  <div>
+                    <BaseIcon
+                      className={`${iconsColor}`}
+                      w='w-16'
+                      h='h-16'
+                      size={48}
+                      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                      // @ts-ignore
+                      path={icon.mdiTable || icon.mdiTable}
+                    />
+                  </div>
+                </div>
+              </div>
+            </Link>
+          )}
         </div>
       </SectionMain>
     </>

frontend/src/pages/games/[gamesId].tsx

@@ -49,6 +49,8 @@ const EditGames = () => {
     opponent_score: '',
 
     leagues: null,
+
+    season: null,
   };
   const [initialValues, setInitialValues] = useState(initVals);
 
@@ -169,6 +171,17 @@ const EditGames = () => {
                 ></Field>
               </FormField>
 
+              <FormField label='Season' labelFor='season'>
+                <Field
+                  name='season'
+                  id='season'
+                  component={SelectField}
+                  options={initialValues.season}
+                  itemRef={'seasons'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/games/games-edit.tsx

@@ -49,6 +49,8 @@ const EditGamesPage = () => {
     opponent_score: '',
 
     leagues: null,
+
+    season: null,
   };
   const [initialValues, setInitialValues] = useState(initVals);
 
@@ -167,6 +169,17 @@ const EditGamesPage = () => {
                 ></Field>
               </FormField>
 
+              <FormField label='Season' labelFor='season'>
+                <Field
+                  name='season'
+                  id='season'
+                  component={SelectField}
+                  options={initialValues.season}
+                  itemRef={'seasons'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/games/games-list.tsx

@@ -35,6 +35,8 @@ const GamesTablesPage = () => {
     { label: 'GameDate', title: 'date', date: 'true' },
 
     { label: 'Team', title: 'team' },
+
+    { label: 'Season', title: 'season' },
   ]);
 
   const hasCreatePermission =

frontend/src/pages/games/games-new.tsx

@@ -44,6 +44,8 @@ const initialValues = {
   opponent_score: '',
 
   leagues: '',
+
+  season: '',
 };
 
 const GamesNew = () => {
@@ -127,6 +129,16 @@ const GamesNew = () => {
                 ></Field>
               </FormField>
 
+              <FormField label='Season' labelFor='season'>
+                <Field
+                  name='season'
+                  id='season'
+                  component={SelectField}
+                  options={[]}
+                  itemRef={'seasons'}
+                ></Field>
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/games/games-table.tsx

@@ -35,6 +35,8 @@ const GamesTablesPage = () => {
     { label: 'GameDate', title: 'date', date: 'true' },
 
     { label: 'Team', title: 'team' },
+
+    { label: 'Season', title: 'season' },
   ]);
 
   const hasCreatePermission =

frontend/src/pages/games/games-view.tsx

@@ -103,6 +103,45 @@ const GamesView = () => {
             <p>{games?.leagues?.name ?? 'No data'}</p>
           </div>
 
+          <div className={'mb-4'}>
+            <p className={'block font-bold mb-2'}>Season</p>
+
+            <p>{games?.season?.name ?? 'No data'}</p>
+          </div>
+
+          <>
+            <p className={'block font-bold mb-2'}>Player_game_scores Game</p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr></tr>
+                  </thead>
+                  <tbody>
+                    {games.player_game_scores_game &&
+                      Array.isArray(games.player_game_scores_game) &&
+                      games.player_game_scores_game.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(
+                              `/player_game_scores/player_game_scores-view/?id=${item.id}`,
+                            )
+                          }
+                        ></tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!games?.player_game_scores_game?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
           <BaseDivider />
 
           <BaseButton

frontend/src/pages/index.tsx

@@ -143,7 +143,7 @@ export default function WebSite() {
         <FeaturesSection
           projectName={'LeagueMule'}
           image={['Icons representing league features']}
-          withBg={0}
+          withBg={1}
           features={features_points}
           mainText={`Unleash the Power of ${projectName}`}
           subTitle={`Explore the innovative features of ${projectName} that make league management a breeze. Simplify your tasks and enhance your league experience.`}

frontend/src/pages/leagues/[leaguesId].tsx

@@ -39,6 +39,8 @@ const EditLeagues = () => {
   const dispatch = useAppDispatch();
   const initVals = {
     name: '',
+
+    handicapformula: '',
   };
   const [initialValues, setInitialValues] = useState(initVals);
 
@@ -97,6 +99,10 @@ const EditLeagues = () => {
                 <Field name='name' placeholder='Name' />
               </FormField>
 
+              <FormField label='Handicapformula'>
+                <Field name='handicapformula' placeholder='Handicapformula' />
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/leagues/leagues-edit.tsx

@@ -39,6 +39,8 @@ const EditLeaguesPage = () => {
   const dispatch = useAppDispatch();
   const initVals = {
     name: '',
+
+    handicapformula: '',
   };
   const [initialValues, setInitialValues] = useState(initVals);
 
@@ -95,6 +97,10 @@ const EditLeaguesPage = () => {
                 <Field name='name' placeholder='Name' />
               </FormField>
 
+              <FormField label='Handicapformula'>
+                <Field name='handicapformula' placeholder='Handicapformula' />
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/leagues/leagues-list.tsx

@@ -28,7 +28,10 @@ const LeaguesTablesPage = () => {
 
   const dispatch = useAppDispatch();
 
-  const [filters] = useState([{ label: 'Name', title: 'name' }]);
+  const [filters] = useState([
+    { label: 'Name', title: 'name' },
+    { label: 'Handicapformula', title: 'handicapformula' },
+  ]);
 
   const hasCreatePermission =
     currentUser && hasPermission(currentUser, 'CREATE_LEAGUES');

frontend/src/pages/leagues/leagues-new.tsx

@@ -34,6 +34,8 @@ import moment from 'moment';
 
 const initialValues = {
   name: '',
+
+  handicapformula: '',
 };
 
 const LeaguesNew = () => {
@@ -67,6 +69,10 @@ const LeaguesNew = () => {
                 <Field name='name' placeholder='Name' />
               </FormField>
 
+              <FormField label='Handicapformula'>
+                <Field name='handicapformula' placeholder='Handicapformula' />
+              </FormField>
+
               <BaseDivider />
               <BaseButtons>
                 <BaseButton type='submit' color='info' label='Submit' />

frontend/src/pages/leagues/leagues-table.tsx

@@ -28,7 +28,10 @@ const LeaguesTablesPage = () => {
 
   const dispatch = useAppDispatch();
 
-  const [filters] = useState([{ label: 'Name', title: 'name' }]);
+  const [filters] = useState([
+    { label: 'Name', title: 'name' },
+    { label: 'Handicapformula', title: 'handicapformula' },
+  ]);
 
   const hasCreatePermission =
     currentUser && hasPermission(currentUser, 'CREATE_LEAGUES');

frontend/src/pages/leagues/leagues-view.tsx

@@ -63,6 +63,11 @@ const LeaguesView = () => {
             <p>{leagues?.name}</p>
           </div>
 
+          <div className={'mb-4'}>
+            <p className={'block font-bold mb-2'}>Handicapformula</p>
+            <p>{leagues?.handicapformula}</p>
+          </div>
+
           <>
             <p className={'block font-bold mb-2'}>Users Leagues</p>
             <CardBox
@@ -331,6 +336,225 @@ const LeaguesView = () => {
             </CardBox>
           </>
 
+          <>
+            <p className={'block font-bold mb-2'}>Seasons leagues</p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr>
+                      <th>Name</th>
+
+                      <th>Startdate</th>
+
+                      <th>Enddate</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {leagues.seasons_leagues &&
+                      Array.isArray(leagues.seasons_leagues) &&
+                      leagues.seasons_leagues.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(`/seasons/seasons-view/?id=${item.id}`)
+                          }
+                        >
+                          <td data-label='name'>{item.name}</td>
+
+                          <td data-label='startdate'>
+                            {dataFormatter.dateFormatter(item.startdate)}
+                          </td>
+
+                          <td data-label='enddate'>
+                            {dataFormatter.dateFormatter(item.enddate)}
+                          </td>
+                        </tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!leagues?.seasons_leagues?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
+          <>
+            <p className={'block font-bold mb-2'}>Seasons League</p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr>
+                      <th>Name</th>
+
+                      <th>Startdate</th>
+
+                      <th>Enddate</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {leagues.seasons_league &&
+                      Array.isArray(leagues.seasons_league) &&
+                      leagues.seasons_league.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(`/seasons/seasons-view/?id=${item.id}`)
+                          }
+                        >
+                          <td data-label='name'>{item.name}</td>
+
+                          <td data-label='startdate'>
+                            {dataFormatter.dateFormatter(item.startdate)}
+                          </td>
+
+                          <td data-label='enddate'>
+                            {dataFormatter.dateFormatter(item.enddate)}
+                          </td>
+                        </tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!leagues?.seasons_league?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
+          <>
+            <p className={'block font-bold mb-2'}>Player_game_scores leagues</p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr></tr>
+                  </thead>
+                  <tbody>
+                    {leagues.player_game_scores_leagues &&
+                      Array.isArray(leagues.player_game_scores_leagues) &&
+                      leagues.player_game_scores_leagues.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(
+                              `/player_game_scores/player_game_scores-view/?id=${item.id}`,
+                            )
+                          }
+                        ></tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!leagues?.player_game_scores_leagues?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
+          <>
+            <p className={'block font-bold mb-2'}>
+              Player_season_stats leagues
+            </p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr>
+                      <th>Totalpoints</th>
+
+                      <th>Gamesplayed</th>
+
+                      <th>Eightballruns</th>
+
+                      <th>Eightballbreaks</th>
+
+                      <th>Nineballruns</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {leagues.player_season_stats_leagues &&
+                      Array.isArray(leagues.player_season_stats_leagues) &&
+                      leagues.player_season_stats_leagues.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(
+                              `/player_season_stats/player_season_stats-view/?id=${item.id}`,
+                            )
+                          }
+                        >
+                          <td data-label='totalpoints'>{item.totalpoints}</td>
+
+                          <td data-label='gamesplayed'>{item.gamesplayed}</td>
+
+                          <td data-label='eightballruns'>
+                            {item.eightballruns}
+                          </td>
+
+                          <td data-label='eightballbreaks'>
+                            {item.eightballbreaks}
+                          </td>
+
+                          <td data-label='nineballruns'>{item.nineballruns}</td>
+                        </tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!leagues?.player_season_stats_leagues?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
+          <>
+            <p className={'block font-bold mb-2'}>Team_season_stats leagues</p>
+            <CardBox
+              className='mb-6 border border-gray-300 rounded overflow-hidden'
+              hasTable
+            >
+              <div className='overflow-x-auto'>
+                <table>
+                  <thead>
+                    <tr></tr>
+                  </thead>
+                  <tbody>
+                    {leagues.team_season_stats_leagues &&
+                      Array.isArray(leagues.team_season_stats_leagues) &&
+                      leagues.team_season_stats_leagues.map((item: any) => (
+                        <tr
+                          key={item.id}
+                          onClick={() =>
+                            router.push(
+                              `/team_season_stats/team_season_stats-view/?id=${item.id}`,
+                            )
+                          }
+                        ></tr>
+                      ))}
+                  </tbody>
+                </table>
+              </div>
+              {!leagues?.team_season_stats_leagues?.length && (
+                <div className={'text-center py-4'}>No data</div>
+              )}
+            </CardBox>
+          </>
+
           <BaseDivider />
 
           <BaseButton

frontend/src/pages/player_game_scores/[player_game_scoresId].tsx

@@ -0,0 +1,183 @@
+import { mdiChartTimelineVariant, mdiUpload } from '@mdi/js';
+import Head from 'next/head';
+import React, { ReactElement, useEffect, useState } from 'react';
+import DatePicker from 'react-datepicker';
+import 'react-datepicker/dist/react-datepicker.css';
+import dayjs from 'dayjs';
+
+import CardBox from '../../components/CardBox';
+import LayoutAuthenticated from '../../layouts/Authenticated';
+import SectionMain from '../../components/SectionMain';
+import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton';
+import { getPageTitle } from '../../config';
+
+import { Field, Form, Formik } from 'formik';
+import FormField from '../../components/FormField';
+import BaseDivider from '../../components/BaseDivider';
+import BaseButtons from '../../components/BaseButtons';
+import BaseButton from '../../components/BaseButton';
+import FormCheckRadio from '../../components/FormCheckRadio';
+import FormCheckRadioGroup from '../../components/FormCheckRadioGroup';
+import FormFilePicker from '../../components/FormFilePicker';
+import FormImagePicker from '../../components/FormImagePicker';
+import { SelectField } from '../../components/SelectField';
+import { SelectFieldMany } from '../../components/SelectFieldMany';
+import { SwitchField } from '../../components/SwitchField';
+import { RichTextField } from '../../components/RichTextField';
+
+import {
+  update,
+  fetch,
+} from '../../stores/player_game_scores/player_game_scoresSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import ImageField from '../../components/ImageField';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+const EditPlayer_game_scores = () => {
+  const router = useRouter();
+  const dispatch = useAppDispatch();
+  const initVals = {
+    leagues: null,
+
+    game: null,
+
+    player: null,
+
+    team: null,
+  };
+  const [initialValues, setInitialValues] = useState(initVals);
+
+  const { player_game_scores } = useAppSelector(
+    (state) => state.player_game_scores,
+  );
+
+  const { currentUser } = useAppSelector((state) => state.auth);
+
+  const { player_game_scoresId } = router.query;
+
+  useEffect(() => {
+    dispatch(fetch({ id: player_game_scoresId }));
+  }, [player_game_scoresId]);
+
+  useEffect(() => {
+    if (typeof player_game_scores === 'object') {
+      setInitialValues(player_game_scores);
+    }
+  }, [player_game_scores]);
+
+  useEffect(() => {
+    if (typeof player_game_scores === 'object') {
+      const newInitialVal = { ...initVals };
+
+      Object.keys(initVals).forEach(
+        (el) => (newInitialVal[el] = player_game_scores[el]),
+      );
+
+      setInitialValues(newInitialVal);
+    }
+  }, [player_game_scores]);
+
+  const handleSubmit = async (data) => {
+    await dispatch(update({ id: player_game_scoresId, data }));
+    await router.push('/player_game_scores/player_game_scores-list');
+  };
+
+  return (
+    <>
+      <Head>
+        <title>{getPageTitle('Edit player_game_scores')}</title>
+      </Head>
+      <SectionMain>
+        <SectionTitleLineWithButton
+          icon={mdiChartTimelineVariant}
+          title={'Edit player_game_scores'}
+          main
+        >
+          {''}
+        </SectionTitleLineWithButton>
+        <CardBox>
+          <Formik
+            enableReinitialize
+            initialValues={initialValues}
+            onSubmit={(values) => handleSubmit(values)}
+          >
+            <Form>
+              <FormField label='leagues' labelFor='leagues'>
+                <Field
+                  name='leagues'
+                  id='leagues'
+                  component={SelectField}
+                  options={initialValues.leagues}
+                  itemRef={'leagues'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Game' labelFor='game'>
+                <Field
+                  name='game'
+                  id='game'
+                  component={SelectField}
+                  options={initialValues.game}
+                  itemRef={'games'}
+                  showField={'date'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Player' labelFor='player'>
+                <Field
+                  name='player'
+                  id='player'
+                  component={SelectField}
+                  options={initialValues.player}
+                  itemRef={'players'}
+                  showField={'first_name'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Team' labelFor='team'>
+                <Field
+                  name='team'
+                  id='team'
+                  component={SelectField}
+                  options={initialValues.team}
+                  itemRef={'teams'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
+              <BaseDivider />
+              <BaseButtons>
+                <BaseButton type='submit' color='info' label='Submit' />
+                <BaseButton type='reset' color='info' outline label='Reset' />
+                <BaseButton
+                  type='reset'
+                  color='danger'
+                  outline
+                  label='Cancel'
+                  onClick={() =>
+                    router.push('/player_game_scores/player_game_scores-list')
+                  }
+                />
+              </BaseButtons>
+            </Form>
+          </Formik>
+        </CardBox>
+      </SectionMain>
+    </>
+  );
+};
+
+EditPlayer_game_scores.getLayout = function getLayout(page: ReactElement) {
+  return (
+    <LayoutAuthenticated permission={'UPDATE_PLAYER_GAME_SCORES'}>
+      {page}
+    </LayoutAuthenticated>
+  );
+};
+
+export default EditPlayer_game_scores;

frontend/src/pages/player_game_scores/player_game_scores-edit.tsx

@@ -0,0 +1,181 @@
+import { mdiChartTimelineVariant, mdiUpload } from '@mdi/js';
+import Head from 'next/head';
+import React, { ReactElement, useEffect, useState } from 'react';
+import DatePicker from 'react-datepicker';
+import 'react-datepicker/dist/react-datepicker.css';
+import dayjs from 'dayjs';
+
+import CardBox from '../../components/CardBox';
+import LayoutAuthenticated from '../../layouts/Authenticated';
+import SectionMain from '../../components/SectionMain';
+import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton';
+import { getPageTitle } from '../../config';
+
+import { Field, Form, Formik } from 'formik';
+import FormField from '../../components/FormField';
+import BaseDivider from '../../components/BaseDivider';
+import BaseButtons from '../../components/BaseButtons';
+import BaseButton from '../../components/BaseButton';
+import FormCheckRadio from '../../components/FormCheckRadio';
+import FormCheckRadioGroup from '../../components/FormCheckRadioGroup';
+import FormFilePicker from '../../components/FormFilePicker';
+import FormImagePicker from '../../components/FormImagePicker';
+import { SelectField } from '../../components/SelectField';
+import { SelectFieldMany } from '../../components/SelectFieldMany';
+import { SwitchField } from '../../components/SwitchField';
+import { RichTextField } from '../../components/RichTextField';
+
+import {
+  update,
+  fetch,
+} from '../../stores/player_game_scores/player_game_scoresSlice';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import { useRouter } from 'next/router';
+import { saveFile } from '../../helpers/fileSaver';
+import dataFormatter from '../../helpers/dataFormatter';
+import ImageField from '../../components/ImageField';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+const EditPlayer_game_scoresPage = () => {
+  const router = useRouter();
+  const dispatch = useAppDispatch();
+  const initVals = {
+    leagues: null,
+
+    game: null,
+
+    player: null,
+
+    team: null,
+  };
+  const [initialValues, setInitialValues] = useState(initVals);
+
+  const { player_game_scores } = useAppSelector(
+    (state) => state.player_game_scores,
+  );
+
+  const { currentUser } = useAppSelector((state) => state.auth);
+
+  const { id } = router.query;
+
+  useEffect(() => {
+    dispatch(fetch({ id: id }));
+  }, [id]);
+
+  useEffect(() => {
+    if (typeof player_game_scores === 'object') {
+      setInitialValues(player_game_scores);
+    }
+  }, [player_game_scores]);
+
+  useEffect(() => {
+    if (typeof player_game_scores === 'object') {
+      const newInitialVal = { ...initVals };
+      Object.keys(initVals).forEach(
+        (el) => (newInitialVal[el] = player_game_scores[el]),
+      );
+      setInitialValues(newInitialVal);
+    }
+  }, [player_game_scores]);
+
+  const handleSubmit = async (data) => {
+    await dispatch(update({ id: id, data }));
+    await router.push('/player_game_scores/player_game_scores-list');
+  };
+
+  return (
+    <>
+      <Head>
+        <title>{getPageTitle('Edit player_game_scores')}</title>
+      </Head>
+      <SectionMain>
+        <SectionTitleLineWithButton
+          icon={mdiChartTimelineVariant}
+          title={'Edit player_game_scores'}
+          main
+        >
+          {''}
+        </SectionTitleLineWithButton>
+        <CardBox>
+          <Formik
+            enableReinitialize
+            initialValues={initialValues}
+            onSubmit={(values) => handleSubmit(values)}
+          >
+            <Form>
+              <FormField label='leagues' labelFor='leagues'>
+                <Field
+                  name='leagues'
+                  id='leagues'
+                  component={SelectField}
+                  options={initialValues.leagues}
+                  itemRef={'leagues'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Game' labelFor='game'>
+                <Field
+                  name='game'
+                  id='game'
+                  component={SelectField}
+                  options={initialValues.game}
+                  itemRef={'games'}
+                  showField={'date'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Player' labelFor='player'>
+                <Field
+                  name='player'
+                  id='player'
+                  component={SelectField}
+                  options={initialValues.player}
+                  itemRef={'players'}
+                  showField={'first_name'}
+                ></Field>
+              </FormField>
+
+              <FormField label='Team' labelFor='team'>
+                <Field
+                  name='team'
+                  id='team'
+                  component={SelectField}
+                  options={initialValues.team}
+                  itemRef={'teams'}
+                  showField={'name'}
+                ></Field>
+              </FormField>
+
+              <BaseDivider />
+              <BaseButtons>
+                <BaseButton type='submit' color='info' label='Submit' />
+                <BaseButton type='reset' color='info' outline label='Reset' />
+                <BaseButton
+                  type='reset'
+                  color='danger'
+                  outline
+                  label='Cancel'
+                  onClick={() =>
+                    router.push('/player_game_scores/player_game_scores-list')
+                  }
+                />
+              </BaseButtons>
+            </Form>
+          </Formik>
+        </CardBox>
+      </SectionMain>
+    </>
+  );
+};
+
+EditPlayer_game_scoresPage.getLayout = function getLayout(page: ReactElement) {
+  return (
+    <LayoutAuthenticated permission={'UPDATE_PLAYER_GAME_SCORES'}>
+      {page}
+    </LayoutAuthenticated>
+  );
+};
+
+export default EditPlayer_game_scoresPage;

frontend/src/pages/player_game_scores/player_game_scores-list.tsx

@@ -0,0 +1,173 @@
+import { mdiChartTimelineVariant } from '@mdi/js';
+import Head from 'next/head';
+import { uniqueId } from 'lodash';
+import React, { ReactElement, useState } from 'react';
+import CardBox from '../../components/CardBox';
+import LayoutAuthenticated from '../../layouts/Authenticated';
+import SectionMain from '../../components/SectionMain';
+import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton';
+import { getPageTitle } from '../../config';
+import TablePlayer_game_scores from '../../components/Player_game_scores/TablePlayer_game_scores';
+import BaseButton from '../../components/BaseButton';
+import axios from 'axios';
+import Link from 'next/link';
+import { useAppDispatch, useAppSelector } from '../../stores/hooks';
+import CardBoxModal from '../../components/CardBoxModal';
+import DragDropFilePicker from '../../components/DragDropFilePicker';
+import {
+  setRefetch,
+  uploadCsv,
+} from '../../stores/player_game_scores/player_game_scoresSlice';
+
+import { hasPermission } from '../../helpers/userPermissions';
+
+const Player_game_scoresTablesPage = () => {
+  const [filterItems, setFilterItems] = useState([]);
+  const [csvFile, setCsvFile] = useState<File | null>(null);
+  const [isModalActive, setIsModalActive] = useState(false);
+  const [showTableView, setShowTableView] = useState(false);
+
+  const { currentUser } = useAppSelector((state) => state.auth);
+
+  const dispatch = useAppDispatch();
+
+  const [filters] = useState([
+    { label: 'Game', title: 'game' },
+
+    { label: 'Player', title: 'player' },
+
+    { label: 'Team', title: 'team' },
+  ]);
+
+  const hasCreatePermission =
+    currentUser && hasPermission(currentUser, 'CREATE_PLAYER_GAME_SCORES');
+
+  const addFilter = () => {
+    const newItem = {
+      id: uniqueId(),
+      fields: {
+        filterValue: '',
+        filterValueFrom: '',
+        filterValueTo: '',
+        selectedField: '',
+      },
+    };
+    newItem.fields.selectedField = filters[0].title;
+    setFilterItems([...filterItems, newItem]);
+  };
+
+  const getPlayer_game_scoresCSV = async () => {
+    const response = await axios({
+      url: '/player_game_scores?filetype=csv',
+      method: 'GET',
+      responseType: 'blob',
+    });
+    const type = response.headers['content-type'];
+    const blob = new Blob([response.data], { type: type });
+    const link = document.createElement('a');
+    link.href = window.URL.createObjectURL(blob);
+    link.download = 'player_game_scoresCSV.csv';
+    link.click();
+  };
+
+  const onModalConfirm = async () => {
+    if (!csvFile) return;
+    await dispatch(uploadCsv(csvFile));
+    dispatch(setRefetch(true));
+    setCsvFile(null);
+    setIsModalActive(false);
+  };
+
+  const onModalCancel = () => {
+    setCsvFile(null);
+    setIsModalActive(false);
+  };
+
+  return (
+    <>
+      <Head>
+        <title>{getPageTitle('Player_game_scores')}</title>
+      </Head>
+      <SectionMain>
+        <SectionTitleLineWithButton
+          icon={mdiChartTimelineVariant}
+          title='Player_game_scores'
+          main
+        >
+          {''}
+        </SectionTitleLineWithButton>
+        <CardBox className='mb-6' cardBoxClassName='flex flex-wrap'>
+          {hasCreatePermission && (
+            <BaseButton
+              className={'mr-3'}
+              href={'/player_game_scores/player_game_scores-new'}
+              color='info'
+              label='New Item'
+            />
+          )}
+
+          <BaseButton
+            className={'mr-3'}
+            color='info'
+            label='Filter'
+            onClick={addFilter}
+          />
+          <BaseButton
+            className={'mr-3'}
+            color='info'
+            label='Download CSV'
+            onClick={getPlayer_game_scoresCSV}
+          />
+
+          {hasCreatePermission && (
+            <BaseButton
+              color='info'
+              label='Upload CSV'
+              onClick={() => setIsModalActive(true)}
+            />
+          )}
+
+          <div className='md:inline-flex items-center ms-auto'>
+            <div id='delete-rows-button'></div>
+          </div>
+        </CardBox>
+
+        <CardBox className='mb-6' hasTable>
+          <TablePlayer_game_scores
+            filterItems={filterItems}
+            setFilterItems={setFilterItems}
+            filters={filters}
+            showGrid={false}
+          />
+        </CardBox>
+      </SectionMain>
+      <CardBoxModal
+        title='Upload CSV'
+        buttonColor='info'
+        buttonLabel={'Confirm'}
+        // buttonLabel={false ? 'Deleting...' : 'Confirm'}
+        isActive={isModalActive}
+        onConfirm={onModalConfirm}
+        onCancel={onModalCancel}
+      >
+        <DragDropFilePicker
+          file={csvFile}
+          setFile={setCsvFile}
+          formats={'.csv'}
+        />
+      </CardBoxModal>
+    </>
+  );
+};
+
+Player_game_scoresTablesPage.getLayout = function getLayout(
+  page: ReactElement,
+) {
+  return (
+    <LayoutAuthenticated permission={'READ_PLAYER_GAME_SCORES'}>
+      {page}
+    </LayoutAuthenticated>
+  );
+};
+
+export default Player_game_scoresTablesPage;