feat: filter rocket Pokemon for unconfirmed grunts

New option "fallbackRocketPokemonFiltering" enables maps to have rocket Pokemon filtering even without rocket scanning capabilities. Disable this switch to revert to the old behavior.

Author: Mygod

config/default.json

@@ -245,6 +245,7 @@
       "enableMapJsFilter": true,
       "fetchLatestInvasions": true,
       "invasionCacheHrs": 1,
+      "fallbackRocketPokemonFiltering": true,
       "masterfileCacheHrs": 6,
       "webhookCacheHrs": 1,
       "questMessage": "",

server/src/models/Pokestop.js

@@ -549,27 +549,61 @@ class Pokestop extends Model {
                 invasion.andWhere('confirmed', onlyConfirmed)
               }
               invasion.andWhere((subQuery) => {
-                if (hasConfirmed) {
-                  if (rocketPokemon.length) {
-                    subQuery
-                      .whereIn('slot_1_pokemon_id', rocketPokemon)
-                      .orWhereIn('slot_2_pokemon_id', rocketPokemon)
-                      .orWhereIn('slot_3_pokemon_id', rocketPokemon)
-                      .orWhereIn(
+                // Case (a): Include if the invasion character/grunt type is checked
+                subQuery.whereIn(
+                  isMad ? 'character_display' : 'character',
+                  invasions,
+                )
+
+                // Case (b): Include if invasion has potential rewards that are checked
+                if (rocketPokemon.length) {
+                  // For confirmed invasions, check actual Pokemon slots
+                  if (hasConfirmed)
+                    subQuery.orWhere((confirmedQuery) => {
+                      confirmedQuery
+                        .where('confirmed', 1)
+                        .andWhere((pokemonQuery) => {
+                          pokemonQuery
+                            .whereIn('slot_1_pokemon_id', rocketPokemon)
+                            .orWhereIn('slot_2_pokemon_id', rocketPokemon)
+                            .orWhereIn('slot_3_pokemon_id', rocketPokemon)
+                        })
+                    })
+
+                  // For unconfirmed invasions, check if their potential rewards match
+                  // Get all grunt types that have potential rewards matching the filter
+                  const gruntTypesWithMatchingRewards = []
+                  Object.entries(state.event.invasions).forEach(
+                    ([gruntType, info]) => {
+                      if (!info) return
+                      if (
+                        [
+                          ...(info.firstReward ? info.encounters.first : []),
+                          ...(info.secondReward ? info.encounters.second : []),
+                          ...(info.thirdReward ? info.encounters.third : []),
+                        ].some((poke) =>
+                          rocketPokemon.includes(String(poke.id)),
+                        )
+                      ) {
+                        gruntTypesWithMatchingRewards.push(gruntType)
+                      }
+                    },
+                  )
+
+                  if (gruntTypesWithMatchingRewards.length > 0) {
+                    subQuery.orWhere((unconfirmedQuery) => {
+                      unconfirmedQuery.whereIn(
                         isMad ? 'character_display' : 'character',
-                        invasions,
+                        gruntTypesWithMatchingRewards,
                       )
-                  } else {
-                    subQuery.whereIn(
-                      isMad ? 'character_display' : 'character',
-                      invasions,
-                    )
+                      if (hasConfirmed)
+                        unconfirmedQuery.andWhere((confirmationQuery) => {
+                          confirmationQuery
+                            .where('confirmed', 0)
+                            .orWhereNull('confirmed')
+                        })
+                    })
                   }
-                } else {
-                  subQuery.whereIn(
-                    isMad ? 'character_display' : 'character',
-                    invasions,
-                  )
                 }
               })
               if (onlyExcludeGrunts) {
@@ -1530,6 +1564,37 @@ class Pokestop extends Model {
               }
             })
           }
+
+          if (config.getSafe('map.misc.fallbackRocketPokemonFiltering')) {
+            // Always include potential rocket Pokemon from state.event.invasions as backup
+            Object.values(state.event.invasions).forEach((invasionInfo) => {
+              if (invasionInfo) {
+                // Add all potential first slot rewards
+                if (invasionInfo.firstReward && invasionInfo.encounters.first) {
+                  invasionInfo.encounters.first.forEach((poke) => {
+                    finalList.add(`a${poke.id}-${poke.form}`)
+                  })
+                }
+
+                // Add all potential second slot rewards
+                if (
+                  invasionInfo.secondReward &&
+                  invasionInfo.encounters.second
+                ) {
+                  invasionInfo.encounters.second.forEach((poke) => {
+                    finalList.add(`a${poke.id}-${poke.form}`)
+                  })
+                }
+
+                // Add all potential third slot rewards
+                if (invasionInfo.thirdReward && invasionInfo.encounters.third) {
+                  invasionInfo.encounters.third.forEach((poke) => {
+                    finalList.add(`a${poke.id}-${poke.form}`)
+                  })
+                }
+              }
+            })
+          }
           break
         case 'showcase':
           if (hasShowcaseData) {
@@ -2004,6 +2069,16 @@ class Pokestop extends Model {
    * @returns {Promise<{ hasConfirmedInvasions: boolean }>}
    */
   static async getFilterContext({ isMad, hasConfirmed }) {
+    // Check if rocket Pokemon filtering should be forced via config
+    const fallback = config.getSafe('map.misc.fallbackRocketPokemonFiltering')
+
+    if (fallback) {
+      // Always enable rocket Pokemon filtering regardless of database support
+      // This allows filtering by potential rocket Pokemon even without confirmed invasions
+      return { hasConfirmedInvasions: true }
+    }
+
+    // Use original behavior when config is disabled
     if (isMad || !hasConfirmed) return { hasConfirmedInvasions: false }
     const result = await this.query()
       .from('incident')

server/src/services/EventManager.js

@@ -245,7 +245,7 @@ class EventManager extends Logger {
     if (config.getSafe('api.pogoApiEndpoints.invasions')) {
       this.intervals.invasions = setInterval(
         async () => {
-          await this.getInvasions()
+          await this.getInvasions(Db)
           await this.chatLog('event', { description: 'Refreshed invasions' })
         },
         1000 * 60 * 60 * (config.getSafe('map.misc.invasionCacheHrs') || 1),
@@ -355,7 +355,11 @@ class EventManager extends Logger {
     this[type] = Object.values(this[`${type}Backup`])
   }
 
-  async getInvasions() {
+  /**
+   *
+   * @param {import('./DbManager').DbManager} [Db] - Database manager instance
+   */
+  async getInvasions(Db) {
     const endpoint = config.getSafe('api.pogoApiEndpoints.invasions')
     if (endpoint) {
       this.log.info('Fetching Latest Invasions')
@@ -376,6 +380,11 @@ class EventManager extends Logger {
             .map(Number)
 
           this.invasions = newInvasions
+
+          // Update available rocket Pokemon whenever invasions are refreshed
+          if (Db) {
+            await this.setAvailable('pokestops', 'Pokestop', Db)
+          }
         }
       } catch (e) {
         this.log.warn('Unable to generate latest invasions:\n', e)

server/src/services/state.js

@@ -127,7 +127,7 @@ const state = {
       promises.push(this.pvp.fetchLatestPokemon())
     }
     if (!reloadReport || reloadReport.invasions) {
-      promises.push(this.event.getInvasions())
+      promises.push(this.event.getInvasions(this.db))
     }
     if (!reloadReport || reloadReport.webhooks) {
       promises.push(this.event.getWebhooks())