@golstats/gsc-lineups-reports 1.0.8 → 1.1.0

package/src/components/gsc-lineup-main.vue

@@ -1,65 +1,81 @@
-<template>
-  <div>
-    <template v-if="type == '2D'">
-      <GSCLineups2D :selected-option="selectedOption" :game="game" :socket="socket" />
-    </template>
-    <template v-if="type == '3D'">
-      <GSCLineups3D
-        :is-live="isLive"
-        :isFemale="isFemale"
-        @onOpenProfile="onOpenProfile"
-        :selected-option="selectedOption"
-        :game="game"
-        :socket="socket"
-      />
-    </template>
-  </div>
-</template>
-<script>
-import GSCLineups2D from './gsc-lineup-dosd.vue'
-import GSCLineups3D from './gsc-lineups.vue'
-export default {
-  components: {
-    GSCLineups2D,
-    GSCLineups3D
-  },
-  props: {
-    isFemale: {
-      type: Boolean,
-      default: false
-    },
-    selectedOption: {
-      type: String,
-      default: 'Historicos'
-    },
-    game: {
-      type: Object,
-      default: () => {}
-    },
-    isLive: {
-      type: Boolean,
-      default: false
-    },
-    type: {
-      type: String,
-      default: '2D'
-    },
-    socket: {
-      type: Object,
-      default: () => {}
-    }
-  },
-  watch: {},
-  data() {
-    return {}
-  },
-  computed: {},
-  methods: {
-    onOpenProfile(data) {
-      this.$emit('onOpenProfile', data)
-    }
-  }
-}
-</script>
-
-<style module></style>
+<template>
+  <div>
+    <template v-if="type == '2D'">
+      <GSCLineups2D
+        :selected-option="selectedOption"
+        :game="game"
+        :socket="socket"
+        :provider="provider"
+        :is-dev-apis="isDevApis"
+      />
+    </template>
+    <template v-if="type == '3D'">
+      <GSCLineups3D
+        :is-live="isLive"
+        :isFemale="isFemale"
+        @onOpenProfile="onOpenProfile"
+        :selected-option="selectedOption"
+        :game="game"
+        :socket="socket"
+        :provider="provider"
+        :is-dev-apis="isDevApis"
+      />
+    </template>
+  </div>
+</template>
+<script>
+import GSCLineups2D from './gsc-lineup-dosd.vue'
+import GSCLineups3D from './gsc-lineups.vue'
+export default {
+  components: {
+    GSCLineups2D,
+    GSCLineups3D
+  },
+  props: {
+    isFemale: {
+      type: Boolean,
+      default: false
+    },
+    selectedOption: {
+      type: String,
+      default: 'Historicos'
+    },
+    game: {
+      type: Object,
+      default: () => {}
+    },
+    isLive: {
+      type: Boolean,
+      default: false
+    },
+    type: {
+      type: String,
+      default: '2D'
+    },
+    socket: {
+      type: Object,
+      default: () => {}
+    },
+    provider: {
+      type: Number,
+      default: 1
+    },
+    isDevApis: {
+      type: Boolean,
+      default: false
+    }
+  },
+  watch: {},
+  data() {
+    return {}
+  },
+  computed: {},
+  methods: {
+    onOpenProfile(data) {
+      this.$emit('onOpenProfile', data)
+    }
+  }
+}
+</script>
+
+<style module></style>

package/src/components/gsc-lineups-reports.vue

@@ -1,11 +1,12 @@
 <template>
   <div>
-    <!-- Aquí va tu contenido -->
     <GSCLineups
       :game="game"
       :gamehome="lastHomeGame"
       :gameaway="lastVisitingGame"
       :selected-option="selectedOption"
+      :provider="provider"
+      :is-dev-apis="isDevApis"
     />
   </div>
 </template>
@@ -39,6 +40,14 @@ const props = defineProps({
     type: String,
     default: 'Prematch',
   },
+  provider: {
+    type: Number,
+    default: 1,
+  },
+  isDevApis: {
+    type: Boolean,
+    default: false,
+  },
 })
 
 // Función para validar y formatear el objeto del juego

package/src/components/gsc-lineups.vue

@@ -51,16 +51,6 @@
           <!-- CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA -->
           <!-- CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA -->
           <div :class="canchacontainerClass">
-            <div
-              :class="[notificationnolineupsClass]"
-              v-if="
-                (gameForAnalysis.game_status == 4 || gameForAnalysis.game_status == 1) &&
-                gameForAnalysis.is_live == 0 &&
-                numPlayer == 0
-              "
-            >
-              Las alineaciones estarán disponibles unos minutos antes de que inicie el partido.
-            </div>
             <template v-for="(data, key) in playersHome" :key="key + 'jersey_home'">
               <template v-if="data.played">
                 <div
@@ -284,6 +274,7 @@
 <script>
 import axios from 'axios'
 import { /*connectSocket,*/ connectChannel } from '@/utils/socketConnection'
+import { getApiUrl } from '@/utils/apiUrl'
 import CardPlayer from './gsc-player-card.vue'
 import HeaderPlayerHistorico from './gsc-header-historico-lineup.vue'
 import HeaderPlayerRecientes from './gsc-header-recientes-lineup.vue'
@@ -322,6 +313,14 @@ export default {
       type: Object,
       default: () => {},
     },
+    provider: {
+      type: Number,
+      default: 1,
+    },
+    isDevApis: {
+      type: Boolean,
+      default: false,
+    },
   },
   components: {
     CardPlayer,
@@ -440,6 +439,8 @@ export default {
       pendingRequests: new Set(),
       // Debounce timer para evitar peticiones excesivas
       debounceTimer: null,
+      // Timer para evitar múltiples cargas de probables
+      probablesDebounceTimer: null,
       matchdaysPerTeam: [],
       lastGetGame: 0,
       lastSection: '',
@@ -811,6 +812,18 @@ export default {
     numPlayer() {
       return Number(this.playersAway.length) + Number(this.playersHome.length)
     },
+    shouldShowNoLineupsMessage() {
+      const condition =
+        (this.gameForAnalysis.game_status == 4 || this.gameForAnalysis.game_status == 1) &&
+        this.gameForAnalysis.is_live == 0 &&
+        this.numPlayer == 0
+
+      console.log(
+        `🔍 Condición mensaje: status=${this.gameForAnalysis.game_status}, is_live=${this.gameForAnalysis.is_live}, numPlayer=${this.numPlayer} -> ${condition}`,
+      )
+
+      return condition
+    },
     benchFillHome() {
       if (this.playersHome.length < this.playersAway.length) {
         return this.playersAway.length - this.playersHome.length
@@ -838,6 +851,15 @@ export default {
       }
     }
   },
+  beforeUnmount() {
+    // Limpiar timers para evitar memory leaks
+    if (this.probablesDebounceTimer) {
+      clearTimeout(this.probablesDebounceTimer)
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+    }
+  },
   watch: {
     /*'homeTeam.acronym': {
     handler(newValue) {
@@ -859,7 +881,12 @@ export default {
         if (newValue != oldValue) {
           if (this.selectedOption !== 'Postmatch') {
             if (newValue === 'Probables') {
-              setTimeout(() => {
+              // Limpiar timer anterior para evitar ejecuciones múltiples
+              if (this.probablesDebounceTimer) {
+                clearTimeout(this.probablesDebounceTimer)
+              }
+
+              this.probablesDebounceTimer = setTimeout(async () => {
                 // Validar que los game_id sean válidos antes de proceder
                 if (
                   this.gamehome &&
@@ -869,20 +896,80 @@ export default {
                   this.gameaway.game_id &&
                   this.gameaway.game_id !== 0
                 ) {
-                  console.log(
-                    '✅ Cargando alineaciones probables - Home:',
+                  // Verificar si ya se cargaron las alineaciones para estos game_ids
+                  const alreadyLoaded = this.areProbablesAlreadyLoaded(
                     this.gamehome.game_id,
-                    'Away:',
                     this.gameaway.game_id,
                   )
 
-                  this.auxProbablesIDGameHome = this.gamehome.game_id
-                  this.auxProbablesIDGameAway = this.gameaway.game_id
+                  // Verificar si ya hay peticiones en curso
+                  const requestsPending = this.areProbablesRequestsPending(
+                    this.gamehome.game_id,
+                    this.gameaway.game_id,
+                  )
+
+                  if (requestsPending) {
+                    console.log('⏳ Peticiones de alineaciones probables ya en curso, saltando...')
+                    return
+                  }
 
-                  this.cleaneDataAway()
-                  this.cleaneDataHome()
-                  this.getLineUpProbablesHome3D(this.gamehome.game_id)
-                  this.getLineUpProbablesAway3D(this.gameaway.game_id)
+                  if (!alreadyLoaded) {
+                    console.log(
+                      '✅ Cargando alineaciones probables - Home:',
+                      this.gamehome.game_id,
+                      'Away:',
+                      this.gameaway.game_id,
+                    )
+
+                    this.auxProbablesIDGameHome = this.gamehome.game_id
+                    this.auxProbablesIDGameAway = this.gameaway.game_id
+
+                    console.log('🧹 Limpiando datos antes de cargar nuevas alineaciones...')
+                    this.cleaneDataAway()
+                    this.cleaneDataHome()
+                    console.log(
+                      '📊 Estado después de limpiar - Home:',
+                      this.playersHome.length,
+                      'Away:',
+                      this.playersAway.length,
+                    )
+
+                    // Obtener información del header antes de cargar las alineaciones
+                    console.log('📋 Obteniendo información del header para probables...')
+                    try {
+                      // Verificar que la prop game esté disponible
+                      if (!this.game || !this.game.game_id) {
+                        console.warn('❌ Prop game no disponible para obtener header info')
+                        return
+                      }
+
+                      // Usar la prop game para obtener el header info del partido principal
+                      await this.getHeaderInfo(this.game)
+                      console.log(
+                        '✅ Header info obtenido para el partido principal:',
+                        this.game.game_id,
+                      )
+                    } catch (error) {
+                      console.error('❌ Error obteniendo header info:', error)
+                    }
+
+                    this.getLineUpProbablesHome3D(this.gamehome.game_id)
+                    this.getLineUpProbablesAway3D(this.gameaway.game_id)
+
+                    // Log del estado actual después de iniciar las peticiones
+                    setTimeout(() => {
+                      console.log(
+                        `📊 Estado después de iniciar peticiones - Home: ${this.playersHome.length}, Away: ${this.playersAway.length}, numPlayer: ${this.numPlayer}`,
+                      )
+                    }, 100)
+                  } else {
+                    console.log(
+                      '⏭️ Alineaciones probables ya cargadas para estos game_ids - Home:',
+                      this.gamehome.game_id,
+                      'Away:',
+                      this.gameaway.game_id,
+                    )
+                  }
                 } else {
                   console.warn(
                     '❌ No se pueden cargar alineaciones probables - game_id inválidos:',
@@ -911,6 +998,25 @@ export default {
         }
       },
     },
+    numPlayer: {
+      handler(newValue, oldValue) {
+        if (newValue !== oldValue) {
+          console.log(
+            `👥 numPlayer cambió de ${oldValue} a ${newValue} (Home: ${this.playersHome.length}, Away: ${this.playersAway.length})`,
+          )
+        }
+      },
+    },
+    'gameForAnalysis.game_status': {
+      handler(newValue) {
+        console.log(`🎮 game_status cambió a: ${newValue}`)
+      },
+    },
+    'gameForAnalysis.is_live': {
+      handler(newValue) {
+        console.log(`📡 is_live cambió a: ${newValue}`)
+      },
+    },
     'socket.connected': {
       immediate: true,
       handler(newValue) {
@@ -933,7 +1039,11 @@ export default {
               this.cleaneData()
               await this.getHeaderInfo(newValue)
               const gameDataInfoPromise = axios.get(
-                this.urlGames + newValue.season_id + '/games/' + newValue.game_id,
+                getApiUrl(
+                  this.urlGames + newValue.season_id + '/games/' + newValue.game_id,
+                  this.provider,
+                  this.isDevApis,
+                ),
                 axiosConfig,
               )
               const promises = [gameDataInfoPromise]
@@ -952,7 +1062,10 @@ export default {
                 lineUpsGameId !== this.lastGetLineUpGameId
               ) {
                 console.log('✅ Haciendo petición de alineaciones para game_id:', lineUpsGameId)
-                lineUpsPromise = axios.get(this.url + lineUpsGameId, axiosConfig)
+                lineUpsPromise = axios.get(
+                  getApiUrl(this.url + lineUpsGameId, this.provider, this.isDevApis),
+                  axiosConfig,
+                )
                 promises.push(lineUpsPromise)
               } else if (lineUpsGameId === 0) {
                 console.warn('❌ Se evitó petición con game_id = 0')
@@ -1864,6 +1977,16 @@ export default {
       this.pendingRequests.delete(requestKey)
       console.log(`🔓 Removiendo petición pendiente: ${requestKey}`)
     },
+    // Función para verificar si las alineaciones probables ya están cargadas
+    areProbablesAlreadyLoaded(homeGameId, awayGameId) {
+      return (
+        this.auxProbablesIDGameHome === homeGameId && this.auxProbablesIDGameAway === awayGameId
+      )
+    },
+    // Función para verificar si hay peticiones pendientes para probables
+    areProbablesRequestsPending(homeGameId, awayGameId) {
+      return this.isRequestPending(homeGameId, 'home') || this.isRequestPending(awayGameId, 'away')
+    },
     // Función para calcular el ajuste de perspectiva basado en la posición X
     calculatePerspectiveAdjustment(positionX) {
       // Fórmula progresiva: cuanto menor sea positionX, mayor será el ajuste
@@ -1896,6 +2019,7 @@ export default {
       this.$emit('onOpenProfile', data)
     },
     async getLineUpProbablesHome3D(game) {
+      console.log('🏠 Iniciando petición de alineaciones probables HOME para game_id:', game)
       if (game == null || game === 0) {
         console.warn(
           '❌ getLineUpProbablesHome3D: Se intentó hacer petición con game_id inválido:',
@@ -1904,6 +2028,20 @@ export default {
         return
       }
 
+      // Verificar si gameInfoheader está disponible
+      if (!this.gameInfoheader) {
+        console.warn('❌ getLineUpProbablesHome3D: gameInfoheader no está disponible')
+        return
+      }
+
+      // Verificar que gameInfoheader corresponde al partido correcto
+      if (this.game && this.gameInfoheader.id !== this.game.game_id) {
+        console.warn(
+          `❌ getLineUpProbablesHome3D: gameInfoheader (${this.gameInfoheader.id}) no corresponde al partido actual (${this.game.game_id})`,
+        )
+        return
+      }
+
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'home')) {
         console.warn(
@@ -1921,7 +2059,9 @@ export default {
             Authorization: `${this.tokenPremium}`,
           },
         })
-        const data = await axiosInstanceLineUp.get(this.url + game)
+        const data = await axiosInstanceLineUp.get(
+          getApiUrl(this.url + game, this.provider, this.isDevApis),
+        )
         if (!data || !data.data) {
           throw new Error('There is not lineups for this game.')
         }
@@ -1992,6 +2132,9 @@ export default {
               (player) =>
                 player.player_id == data.data.home_team.starting_lineup[0].lineup[index].player_id,
             )
+            console.log(
+              `🏠 Agregando jugador HOME: ${data.data.home_team.starting_lineup[0].lineup[index].player_name}`,
+            )
             this.playersHome.push({
               played: true,
               name: data.data.home_team.starting_lineup[0].lineup[index].player_name,
@@ -2399,6 +2542,7 @@ export default {
         console.log(
           `✅ getLineUpProbablesHome3D: Petición completada exitosamente para game_id: ${game}`,
         )
+        console.log(`📊 Jugadores HOME cargados: ${this.playersHome.length}`)
       } catch (e) {
         // Remover la petición del estado pendiente en caso de error
         this.removeRequestPending(game, 'home')
@@ -2486,6 +2630,7 @@ export default {
       this.movil = false
     },
     async getLineUpProbablesAway3D(game) {
+      console.log('✈️ Iniciando petición de alineaciones probables AWAY para game_id:', game)
       if (game == null || game === 0) {
         console.warn(
           '❌ getLineUpProbablesAway3D: Se intentó hacer petición con game_id inválido:',
@@ -2494,6 +2639,20 @@ export default {
         return
       }
 
+      // Verificar si gameInfoheader está disponible
+      if (!this.gameInfoheader) {
+        console.warn('❌ getLineUpProbablesAway3D: gameInfoheader no está disponible')
+        return
+      }
+
+      // Verificar que gameInfoheader corresponde al partido correcto
+      if (this.game && this.gameInfoheader.id !== this.game.game_id) {
+        console.warn(
+          `❌ getLineUpProbablesAway3D: gameInfoheader (${this.gameInfoheader.id}) no corresponde al partido actual (${this.game.game_id})`,
+        )
+        return
+      }
+
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'away')) {
         console.warn(
@@ -2511,7 +2670,9 @@ export default {
             Authorization: `${this.tokenPremium}`,
           },
         })
-        const data = await axiosInstanceLineUp.get(this.url + game)
+        const data = await axiosInstanceLineUp.get(
+          getApiUrl(this.url + game, this.provider, this.isDevApis),
+        )
         if (!data || !data.data) {
           throw new Error('There is not lineups for this game.')
         }
@@ -2586,6 +2747,9 @@ export default {
               (player) =>
                 player.player_id == data.data.home_team.starting_lineup[0].lineup[index].player_id,
             )
+            console.log(
+              `✈️ Agregando jugador AWAY: ${data.data.home_team.starting_lineup[0].lineup[index].player_name}`,
+            )
             this.playersAway.push({
               played: true,
               name: data.data.home_team.starting_lineup[0].lineup[index].player_name,
@@ -2985,6 +3149,7 @@ export default {
         console.log(
           `✅ getLineUpProbablesAway3D: Petición completada exitosamente para game_id: ${game}`,
         )
+        console.log(`📊 Jugadores AWAY cargados: ${this.playersAway.length}`)
       } catch (e) {
         // Remover la petición del estado pendiente en caso de error
         this.removeRequestPending(game, 'away')
@@ -2998,8 +3163,8 @@ export default {
           console.log('✅ getLineupProbablesHome: Cargando alineaciones para game_id:', val.id)
           this.auxProbablesIDGameHome = val.id
           //this.homeTeam.acronym = this.awayTeamAbrev
-          this.cleaneDataHome()
-          this.getLineUpProbablesHome3D(val.id)
+          //this.cleaneDataHome()
+          //this.getLineUpProbablesHome3D(val.id)
         }
       } else {
         console.warn('❌ getLineupProbablesHome: game_id inválido:', val?.id)
@@ -3011,8 +3176,8 @@ export default {
           console.log('✅ getLineupProbablesAway: Cargando alineaciones para game_id:', val.id)
           this.auxProbablesIDGameAway = val.id
           //this.visitingTeam.acronym = this.awayTeamAbrev
-          this.cleaneDataAway()
-          this.getLineUpProbablesAway3D(val.id)
+          //this.cleaneDataAway()
+          //this.getLineUpProbablesAway3D(val.id)
         }
       } else {
         console.warn('❌ getLineupProbablesAway: game_id inválido:', val?.id)
@@ -3077,13 +3242,27 @@ export default {
       const data =
         responseData ||
         (await axiosInstance.get(
-          'https://fxtcaw9tw6.execute-api.us-east-2.amazonaws.com/prod/historic/seasons/' +
-            game.season_id +
-            '/games/' +
-            game.game_id +
-            '/lineups',
+          getApiUrl(
+            'https://fxtcaw9tw6.execute-api.us-east-2.amazonaws.com/prod/historic/seasons/' +
+              game.season_id +
+              '/games/' +
+              game.game_id +
+              '/lineups',
+            this.provider,
+            this.isDevApis,
+          ),
         ))
+      console.log(
+        'GAME INFO HEADER --------------------------------------------------------> ',
+        game.game_id,
+      )
       this.gameInfoheader = data.data.game
+      console.log(
+        '📋 gameInfoheader establecido para game_id:',
+        this.gameInfoheader.id,
+        'del partido:',
+        game.game_id,
+      )
       if (this.selectedOption != 'Postmatch') {
         for (let index = 0; index < data.data.games_historic.length; index++) {
           this.gamesHistoric.push({
@@ -3162,7 +3341,13 @@ export default {
       })
       const data =
         responseData ||
-        (await axiosInstance.get(this.urlGames + game.season_id + '/games/' + game.game_id))
+        (await axiosInstance.get(
+          getApiUrl(
+            this.urlGames + game.season_id + '/games/' + game.game_id,
+            this.provider,
+            this.isDevApis,
+          ),
+        ))
       this.homeTeam = data.data.teams[0]
       //this.homeTeamAbrev = data.data.teams[0].acronym
       //this.awayTeamAbrev = data.data.teams[1].acronym
@@ -3316,7 +3501,7 @@ export default {
     },
     async getMXM(game) {
       try {
-        const getMXMUrl = this.urlMXM + game
+        const getMXMUrl = getApiUrl(this.urlMXM + game, this.provider, this.isDevApis)
         if (getMXMUrl === this.lastMXMUrl) {
           return
         }
@@ -3500,7 +3685,10 @@ export default {
         console.warn('❌ getLineUp: Se intentó hacer petición con game_id inválido:', game)
         return
       }
-
+      console.log(
+        '------------------------------------------------> SE HIZO LA PETICION ----> DEL PARTIDO ID: ',
+        game,
+      )
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'general')) {
         console.warn(`🔒 getLineUp: Ya hay una petición en curso para game_id: ${game}`)
@@ -3518,7 +3706,11 @@ export default {
             Authorization: `${this.tokenPremium}`,
           },
         })
-        const data = responseData || (await axiosInstanceLineUp.get(this.url + game))
+        const data =
+          responseData ||
+          (await axiosInstanceLineUp.get(
+            getApiUrl(this.url + game, this.provider, this.isDevApis),
+          ))
         if (!data || !data.data) {
           throw new Error('There is not lineups for this game.')
         }