refactor: say() to check chatters so its not checked manually elsewhere

dotabod · Sep 9, 2023 · 0bb3246 · 0bb3246
1 parent 16bff04
commit 0bb3246
Show file tree

Hide file tree

Showing 16 changed files with 88 additions and 142 deletions.
diff --git a/docker-compose-dev.yml b/docker-compose-dev.yml
@@ -1,18 +1,15 @@
 services:
   twitch-chat:
-    platform: linux/arm64
     image: "ghcr.io/dotabod/twitch-chat:v2.0"
     volumes:
       - ./packages/twitch/chat/src:/app/packages/twitch/chat/src
 
   twitch-events:
-    platform: linux/arm64
     image: "ghcr.io/dotabod/twitch-events:v2.0"
     volumes:
       - ./packages/twitch/events/src:/app/packages/twitch/events/src
 
   dota:
-    platform: linux/arm64
     image: "ghcr.io/dotabod/dota:v2.0"
     volumes:
       - ./packages/dota/src:/app/packages/dota/src

diff --git a/packages/dota/src/dota/GSIHandler.ts b/packages/dota/src/dota/GSIHandler.ts
@@ -199,7 +199,7 @@ export class GSIHandler {
       .then(({ record }) => {
         server.io.to(this.client.token).emit('update-wl', record)
       })
-      .catch((e) => {
+      .catch(() => {
         // Stream not live
         // console.error('[MMR] emitWLUpdate Error getting WL', {e: e?.message || e})
       })
@@ -230,7 +230,7 @@ export class GSIHandler {
           }, 60 * 2000)
         }
       })
-      .catch((e) => {
+      .catch(() => {
         // stream not live
       })
   }
@@ -544,14 +544,10 @@ export class GSIHandler {
         return
       }
 
-      const tellChatBets = getValueOrDefault(DBSettings.tellChatBets, client.settings)
-      const chattersEnabled = getValueOrDefault(DBSettings.chatter, client.settings)
-
-      if (chattersEnabled && tellChatBets) {
-        say(client, t('bets.open', { emote: 'peepoGamble', lng: client.locale }), {
-          delay: false,
-        })
-      }
+      say(client, t('bets.open', { emote: 'peepoGamble', lng: client.locale }), {
+        delay: false,
+        key: DBSettings.tellChatBets,
+      })
       this.openingBets = false
       logger.info('[BETS] open bets', {
         event: 'open_bets',
@@ -642,11 +638,15 @@ export class GSIHandler {
       })
 
       if (this.client.stream_online) {
-        const tellChatBets = getValueOrDefault(DBSettings.tellChatBets, this.client.settings)
-        const chattersEnabled = getValueOrDefault(DBSettings.chatter, this.client.settings)
-        if (chattersEnabled && tellChatBets) {
-          say(this.client, t('bets.notScored', { emote: 'D:', lng: this.client.locale, matchId }))
-        }
+        say(
+          this.client,
+          t('bets.notScored', {
+            emote: 'D:',
+            lng: this.client.locale,
+            matchId,
+            key: DBSettings.tellChatBets,
+          }),
+        )
         await refundTwitchBet(this.getChannelId())
       }
       await this.resetClientState()
@@ -707,10 +707,12 @@ export class GSIHandler {
         ? t('bets.won', { lng: this.client.locale, emote: 'Happi' })
         : t('bets.lost', { lng: this.client.locale, emote: 'Happi' })
 
-      say(this.client, message, { delay: false })
+      say(this.client, message, { delay: false, chattersKey: 'matchOutcome' })
 
       if (!betsEnabled) {
-        logger.info('Bets are not enabled, stopping here', { name: this.client.name })
+        logger.info('Bets are not enabled, stopping here', {
+          name: this.client.name,
+        })
         this.resetClientState().catch(() => {
           //
         })
@@ -739,15 +741,6 @@ export class GSIHandler {
           this.resetClientState().catch((e) => {
             logger.error('Error resetting client state', { e })
           })
-
-          const chattersEnabled = getValueOrDefault(DBSettings.chatter, this.client.settings)
-          const {
-            matchOutcome: { enabled: chatterEnabled },
-          } = getValueOrDefault(DBSettings.chatters, this.client.settings)
-
-          if (!chattersEnabled || !chatterEnabled) {
-            return
-          }
         })
     }, getStreamDelay(this.client.settings))
   }
@@ -780,8 +773,7 @@ export class GSIHandler {
 
           if (this.client.stream_online) {
             const tellChatBets = getValueOrDefault(DBSettings.tellChatBets, this.client.settings)
-            const chattersEnabled = getValueOrDefault(DBSettings.chatter, this.client.settings)
-            if (chattersEnabled && tellChatBets) {
+            if (tellChatBets) {
               say(
                 this.client,
                 t('bets.notScored', { emote: 'D:', lng: this.client.locale, matchId }),

diff --git a/packages/dota/src/dota/events/gsi-events/event.aegis_denied.ts b/packages/dota/src/dota/events/gsi-events/event.aegis_denied.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import { DotaEvent, DotaEventTypes } from '../../../types.js'
@@ -18,15 +17,10 @@ eventHandler.registerEvent(`event:${DotaEventTypes.AegisDenied}`, {
 
     const heroName = getHeroNameOrColor(matchPlayers[event.player_id]?.heroid ?? 0, event.player_id)
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      roshDeny: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-
-    if (chattersEnabled && chatterEnabled)
-      say(
-        dotaClient.client,
-        t('aegis.denied', { lng: dotaClient.client.locale, heroName, emote: 'ICANT' }),
-      )
+    say(
+      dotaClient.client,
+      t('aegis.denied', { lng: dotaClient.client.locale, heroName, emote: 'ICANT' }),
+      { chattersKey: 'roshDeny' },
+    )
   },
 })
diff --git a/packages/dota/src/dota/events/gsi-events/event.aegis_picked_up.ts b/packages/dota/src/dota/events/gsi-events/event.aegis_picked_up.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import RedisClient from '../../../db/RedisClient.js'
@@ -82,14 +81,9 @@ eventHandler.registerEvent(`event:${DotaEventTypes.AegisPickedUp}`, {
     const redisClient = RedisClient.getInstance()
     await redisClient.client.json.set(`${dotaClient.getToken()}:aegis`, '$', res)
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      roshPickup: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-
-    if (chattersEnabled && chatterEnabled) {
-      say(dotaClient.client, generateAegisMessage(res, dotaClient.client.locale))
-    }
+    say(dotaClient.client, generateAegisMessage(res, dotaClient.client.locale), {
+      chattersKey: 'roshPickup',
+    })
 
     emitAegisEvent(res, dotaClient.getToken())
   },

diff --git a/packages/dota/src/dota/events/gsi-events/event.bounty_rune_pickup.ts b/packages/dota/src/dota/events/gsi-events/event.bounty_rune_pickup.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import { DotaEvent, DotaEventTypes } from '../../../types.js'
@@ -15,12 +14,6 @@ eventHandler.registerEvent(`event:${DotaEventTypes.BountyPickup}`, {
     if (!dotaClient.client.stream_online) return
     if (Number(dotaClient.client.gsi?.map?.clock_time) > 120) return
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      bounties: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-    if (!chattersEnabled || !chatterEnabled) return
-
     const playingTeam =
       (await redisClient.client.get(`${dotaClient.client.token}:playingTeam`)) ??
       dotaClient.client.gsi?.player?.team_name
@@ -80,6 +73,7 @@ eventHandler.registerEvent(`event:${DotaEventTypes.BountyPickup}`, {
           totalBounties: dotaClient.bountyHeroNames.length,
           heroNames: bountyHeroNamesString,
         }),
+        { chattersKey: 'bounties' },
       )
       dotaClient.bountyHeroNames = []
     }, 15000)

diff --git a/packages/dota/src/dota/events/gsi-events/event.roshan_killed.ts b/packages/dota/src/dota/events/gsi-events/event.roshan_killed.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import RedisClient from '../../../db/RedisClient.js'
@@ -100,11 +99,6 @@ eventHandler.registerEvent(`event:${DotaEventTypes.RoshanKilled}`, {
     const minDate = dotaClient.addSecondsToNow(minS)
     const maxDate = dotaClient.addSecondsToNow(maxS)
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      roshanKilled: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-
     const redisClient = RedisClient.getInstance()
     // TODO: move this to a redis handler
     const redisJson = (await redisClient.client.json.get(
@@ -123,9 +117,9 @@ eventHandler.registerEvent(`event:${DotaEventTypes.RoshanKilled}`, {
 
     await redisClient.client.json.set(`${dotaClient.getToken()}:roshan`, '$', res)
 
-    if (chattersEnabled && chatterEnabled) {
-      say(dotaClient.client, generateRoshanMessage(res, dotaClient.client.locale))
-    }
+    say(dotaClient.client, generateRoshanMessage(res, dotaClient.client.locale), {
+      chattersKey: 'roshanKilled',
+    })
 
     emitRoshEvent(res, dotaClient.getToken())
   },

diff --git a/packages/dota/src/dota/events/gsi-events/event.tip.ts b/packages/dota/src/dota/events/gsi-events/event.tip.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import { DotaEvent, DotaEventTypes } from '../../../types.js'
@@ -14,13 +13,6 @@ eventHandler.registerEvent(`event:${DotaEventTypes.Tip}`, {
     if (!dotaClient.client.stream_online) return
     if (!isPlayingMatch(dotaClient.client.gsi)) return
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      tip: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-
-    if (!chattersEnabled || !chatterEnabled) return
-
     const { matchPlayers } = await getAccountsFromMatch({ gsi: dotaClient.client.gsi })
 
     const heroName = getHeroNameOrColor(
@@ -35,6 +27,7 @@ eventHandler.registerEvent(`event:${DotaEventTypes.Tip}`, {
       say(
         dotaClient.client,
         t('tip.from', { emote: 'ICANT', lng: dotaClient.client.locale, heroName }),
+        { chattersKey: 'tip' },
       )
     }
 
@@ -47,6 +40,7 @@ eventHandler.registerEvent(`event:${DotaEventTypes.Tip}`, {
       say(
         dotaClient.client,
         t('tip.to', { emote: 'PepeLaugh', lng: dotaClient.client.locale, heroName: toHero }),
+        { chattersKey: 'tip' },
       )
     }
   },

diff --git a/packages/dota/src/dota/events/gsi-events/hero.name.ts b/packages/dota/src/dota/events/gsi-events/hero.name.ts
@@ -32,8 +32,7 @@ eventHandler.registerEvent(`hero:name`, {
       }
 
       const tellChatBets = getValueOrDefault(DBSettings.tellChatBets, dotaClient.client.settings)
-      const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-      if (tellChatBets && chattersEnabled)
+      if (tellChatBets)
         say(
           dotaClient.client,
           t('bets.remade', {

diff --git a/packages/dota/src/dota/events/gsi-events/hero.smoked.ts b/packages/dota/src/dota/events/gsi-events/hero.smoked.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import { GSIHandler, redisClient } from '../../GSIHandler.js'
@@ -11,12 +10,6 @@ eventHandler.registerEvent(`hero:smoked`, {
   handler: async (dotaClient: GSIHandler, isSmoked: boolean) => {
     if (!dotaClient.client.stream_online) return
     if (!isPlayingMatch(dotaClient.client.gsi)) return
-    const chatterEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    if (!chatterEnabled) return
-
-    const chatters = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-
-    if (!chatters.smoke.enabled) return
 
     if (isSmoked) {
       const playingHero = (await redisClient.client.get(
@@ -29,6 +22,7 @@ eventHandler.registerEvent(`hero:smoked`, {
       say(
         dotaClient.client,
         t('chatters.smoked', { emote: 'Shush', heroName, lng: dotaClient.client.locale }),
+        { chattersKey: 'smoke' },
       )
     }
   },

diff --git a/packages/dota/src/dota/events/gsi-events/map.paused.ts b/packages/dota/src/dota/events/gsi-events/map.paused.ts
@@ -1,4 +1,3 @@
-import { DBSettings, getValueOrDefault } from '@dotabod/settings'
 import { t } from 'i18next'
 
 import { GSIHandler } from '../../GSIHandler.js'
@@ -12,18 +11,15 @@ eventHandler.registerEvent(`map:paused`, {
     if (!dotaClient.client.stream_online) return
 
     if (!isPlayingMatch(dotaClient.client.gsi)) return
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
-    const {
-      pause: { enabled: chatterEnabled },
-    } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
 
     // Necessary to let the frontend know, so we can pause any rosh / aegis / etc timers
     server.io.to(dotaClient.getToken()).emit('paused', isPaused)
 
-    if (isPaused && chattersEnabled && chatterEnabled) {
+    if (isPaused) {
       say(
         dotaClient.client,
         t('chatters.pause', { emote: 'PauseChamp', lng: dotaClient.client.locale }),
+        { chattersKey: 'pause' },
       )
     }
   },

diff --git a/packages/dota/src/dota/events/gsi-events/newdata.ts b/packages/dota/src/dota/events/gsi-events/newdata.ts
@@ -20,19 +20,15 @@ function chatterMatchFound(client: SocketClient) {
 
   const commands = DelayedCommands.filter((cmd) => getValueOrDefault(cmd.key, client.settings))
 
-  const chattersEnabled = getValueOrDefault(DBSettings.chatter, client.settings)
-  const {
-    commandsReady: { enabled: chatterEnabled },
-  } = getValueOrDefault(DBSettings.chatters, client.settings)
-
-  if (commands.length && chattersEnabled && chatterEnabled) {
+  if (commands.length) {
     say(
       client,
       t('matchFound', {
         commandList: commands.map((c) => c.command).join(' · '),
         lng: client.locale,
       }),
       {
+        chattersKey: 'commandsReady',
         delay: false,
       },
     )
@@ -53,12 +49,15 @@ async function saveMatchData(client: SocketClient) {
   if (!client.steam32Id) return
 
   // did we already come here before?
-  let [steamServerId, lobbyType] = await redisClient.client
+  const res = await redisClient.client
     .multi()
     .get(`${matchId}:steamServerId`)
     .get(`${matchId}:lobbyType`)
     .exec()
 
+  let [steamServerId] = res
+  const [, lobbyType] = res
+
   if (steamServerId && lobbyType) return
 
   if (!steamServerId && !lobbyType) {
@@ -134,13 +133,12 @@ eventHandler.registerEvent(`newdata`, {
       return
     }
 
-    const chattersEnabled = getValueOrDefault(DBSettings.chatter, dotaClient.client.settings)
     const {
       powerTreads: { enabled: treadsChatterEnabled },
     } = getValueOrDefault(DBSettings.chatters, dotaClient.client.settings)
-    if (chattersEnabled && treadsChatterEnabled) {
+    if (treadsChatterEnabled) {
       try {
-        void calculateManaSaved(dotaClient)
+        await calculateManaSaved(dotaClient)
       } catch (e) {
         logger.error('err calculateManaSaved', { e })
       }