@futdevpro/nts-dynamo 1.10.77 → 1.11.2

package/src/_modules/discord-bot/_models/global-bot-log-settings.interface.ts

@@ -0,0 +1,98 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+import { DyNTS_DiBo_Command } from './dibo-command.interface';
+
+export interface DyNTS_DiBo_Global_Settings {
+  /**
+   * this setting will set the debug level for the bot
+   * 
+   * 0 - no logs  
+   * 1 - errors sending to report channel  
+   * 2 - errors sending as response, will log events in console   
+   * 3 - errors sending as response, creating reports to report channel, debug events are in console (default)  
+   * 4 - errors and debug events are sending as response  
+   * 5 - all events are sending as response (that are set to send)  
+   * 6 - all debug logs are enabled  
+   *   
+   *   _
+   */
+  debugLevel: number;
+
+  /**
+   * this setting will set the intents for the bot
+   */
+  intents: GatewayIntentBits[];
+
+  /**
+   * this setting will set the partials for the bot
+   */
+  partials: Partials[];
+
+  allowedUsers: 'all' | string[];
+
+  messageSettings: {
+    /**
+     * this setting will set the time limit for message fetching
+     * so we will stop fetching messages sent later than this time
+     */
+    messageFetchTimeLimit: number;
+    /**
+     * this setting will set the count limit for message fetching
+     * so we will stop fetching messages after this count
+     */
+    messageFetchCountLimit: number;
+    /**
+     * this setting will set the delay for message sending,
+     * so we won't flood the channel too fast
+     */
+    messageSendDelay: number;
+
+    /**
+     * this setting will be used to skip answering to messages
+     * if the message contains any of these flags, the bot will not answer
+     * 
+     * @default [ '[BOT-SKIP]' ]
+     */
+    skipFlags: string[];
+  };
+
+  /**
+   * this setting will set the channel settings for the bot
+   */
+  channelSettings: {
+    /**
+     * this setting will set the name of the channel where the bot will send the reports
+     * 
+     * @default 'bot-report'
+     */
+    reportChannelName: string;
+
+    /**
+     * this setting will set the channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * it will be populated automatically from the default channels
+     */
+    allowedChannels: string[];
+    /**
+     * this setting will set if the bot can answer in Direct Messages Channels
+     * 
+     * @default false
+     */
+    dmIsAllowed: boolean;
+
+    /**
+     * this setting will set the default channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * @default [ 'bot-report' ]
+     */
+    defaultChannels: string[];
+  };
+
+  commandSettings: {
+    commandOperator: string;
+    commands: DyNTS_DiBo_Command[];
+  };
+
+  allowBotsInteractEachOther: boolean;
+}

package/src/_modules/discord-bot/_services/dibo-commands.control-service.ts

@@ -0,0 +1,120 @@
+
+import { Guild, Message } from 'discord.js';
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
+
+
+export abstract class Commands_ControlService extends DyNTS_SingletonService {
+
+  static getInstance(): Commands_ControlService {
+    return Commands_ControlService.getSingletonInstance();
+  }
+
+  protected abstract getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService;
+  protected readonly mainDiscordBot_CS: DyNTS_DiBo_Main_ControlService = 
+    this.getMainDiscordBotControlService();
+
+  get discordServer(): Guild {
+    return this.mainDiscordBot_CS.discordServer;
+  }
+
+  protected constructor() {
+    super();
+
+    if (!this.discordServer) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'constructor', 
+          new Error(
+            'Discord server not yet initialized, ' +
+            'should only be called after DyNTS_DiBo_Main_ControlService.start'
+          ), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-C00`,
+      })
+    }
+  }
+
+  async handleCommand(message: Message, issuer: string): Promise<void> {
+    try {
+      let haveCommandOperator = false;
+      let msg = message.content.replace(
+        `<@${this.mainDiscordBot_CS.client.user.id}>`, ''
+      ).trim();
+
+      if (!DyNTS_DiBo_global_settings.commandSettings.commandOperator) {
+        haveCommandOperator = true;
+      } else if (
+        msg.startsWith(DyNTS_DiBo_global_settings.commandSettings.commandOperator)
+      ) {
+        haveCommandOperator = true;
+        msg = msg.replace(DyNTS_DiBo_global_settings.commandSettings.commandOperator, '');
+      }
+
+      if (!haveCommandOperator) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'handleCommand', 
+            new Error('No command operator found in the message'), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-HC1`,
+        })
+      }
+
+      const commandExists = DyNTS_DiBo_global_settings.commandSettings.commands.find(
+        (command) => msg.startsWith(command.command)
+      );
+
+      if (!commandExists) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'handleCommand', 
+            new Error(`Command not found: "${msg.split(' ')[0]}"`), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-HC2`,
+        })
+      }
+
+      if (commandExists.permissionNeeded) {
+        const permissionNeeded = await commandExists.permissionNeeded(message);
+
+        if (!permissionNeeded) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings(
+              'handleCommand', 
+              new Error('Permission needed'), 
+              issuer
+            ),
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-HC3`,
+          })
+        }
+      }
+
+      await commandExists.commandHandler(message);
+    } catch (error) {
+      message.reply(
+        `Error occurred while handling the command:\n` +
+        DyFM_Error.getAnyMessage(error)
+      )
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-HC0`,
+      })
+    }
+  }
+
+}
+
+
+
+
+

package/src/_modules/discord-bot/_services/dibo-io.control-service.ts

@@ -0,0 +1,245 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, TextChannel } from 'discord.js'
+import * as dotenv from 'dotenv'
+import { DyFM_Error, DyFM_Log, hour, week } from '@futdevpro/fsm-dynamo'
+import { DyNTS_DiBo_Routines_ControlService } from './dibo-routines.control-service'
+import { Commands_ControlService } from './dibo-commands.control-service'
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service'
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service'
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const'
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts'
+
+/* type T_Main_CS = DyNTS_DiBo_Main_ControlService; */
+
+export abstract class DyNTS_DiBo_IO_ControlService extends DyNTS_SingletonService {
+
+  /* static getInstance(): DyNTS_DiBo_IO_ControlService {
+    return DyNTS_DiBo_IO_ControlService.getSingletonInstance();
+  } */
+
+  protected readonly mainDiscordBot_CS: DyNTS_DiBo_Main_ControlService;
+
+  get discordServer(): Guild {
+    return this.mainDiscordBot_CS.discordServer;
+  }
+  get botClientId(): string {
+    return this.mainDiscordBot_CS.botClientId;
+  }
+  get botDisplayName(): string {
+    return this.mainDiscordBot_CS.botDisplayName;
+  }
+
+  protected abstract getCommandsControlService(): Commands_ControlService;
+  protected readonly commands_CS: Commands_ControlService = this.getCommandsControlService();
+
+  protected constructor() {
+    super();
+
+    if (!this.discordServer) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'constructor', 
+          new Error(
+            'Discord server not yet initialized, ' +
+            'should only be called after DyNTS_DiBo_Main_ControlService.start'
+          ), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-IO-C000`,
+      })
+    }
+  }  
+
+  async handleNewMessage(message: Message, issuer: string): Promise<void> {
+    try {
+      if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
+        DyFM_Log.log(`incoming message: (${message.author.displayName}) ${message.content}`)
+      }
+
+      const isForYou = await this.getMessageIsForBotToHandle(message, issuer);
+
+      if (!isForYou) {
+        return;
+      }
+
+      const isHandledAsCommand = await this.handleIfCommand(message, issuer);
+
+      if (isHandledAsCommand) {
+        return;
+      }
+
+      await this.handleMessage(message, issuer);
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error handleNewMessage:', error);
+
+      if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
+        await message.reply(
+          `[SYSTEM|ERROR] Error occurred while handling the message:\n` +
+          DyFM_Error.getAnyMessage(error)
+        ).catch(error => {
+          DyFM_Error.logSimple('❌❌ Error sending message to report channel:', error);
+        });
+      }
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleNewMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-MCS-H0`,
+      })
+    }
+  }
+
+  abstract handleMessage(message: Message, issuer: string): Promise<void>;
+
+  async getMessageIsForBotToHandle(message: Message, issuer: string): Promise<boolean> {
+    try {
+      const messageIsReplyTo: Message = message.channel.messages.cache.get(
+        message?.reference?.messageId
+      );
+      const isReplyForYou = messageIsReplyTo && messageIsReplyTo.author.id === this.botClientId;    
+      const isPinged = message.content.includes(this.botClientId) || 
+        message.cleanContent.includes(`@${this.botDisplayName}`) ||
+        isReplyForYou;
+      const isOwnMessage = message.author.id === this.botClientId || 
+        message.author.displayName === this.botDisplayName;
+      const haveSkipFlags = DyNTS_DiBo_global_settings.messageSettings.skipFlags.some(
+        flag => message.content.includes(flag)
+      );
+      const channelName = (message.channel as TextChannel)?.name;
+      const isInDefaultChannel = DyNTS_DiBo_global_settings.channelSettings.defaultChannels.includes(
+        channelName
+      );
+      const isDMChannel = message.channel.isDMBased();
+      const isAllowedChannel = DyNTS_DiBo_global_settings.channelSettings.allowedChannels.includes(
+        channelName
+      ) || (isDMChannel && DyNTS_DiBo_global_settings.channelSettings.dmIsAllowed);
+      const isAllowedUser = DyNTS_DiBo_global_settings.allowedUsers === 'all' || 
+        DyNTS_DiBo_global_settings.allowedUsers.includes(message.author.id) ||
+        DyNTS_DiBo_global_settings.allowedUsers.includes(message.author.username) ||
+        DyNTS_DiBo_global_settings.allowedUsers.includes(message.author.displayName);
+
+      if (!isAllowedChannel) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed channel. END')
+        }
+
+        return false;
+      }
+      
+      if (isOwnMessage) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖 will not answer; own message')
+        }
+
+        return false;
+      }
+
+      if (haveSkipFlags) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🏳️ not for me; this message have some skip flags:', 
+            DyNTS_DiBo_global_settings.messageSettings.skipFlags.filter(
+              flag => message.content.includes(flag)
+            ),
+            message.content
+          )
+        }
+
+        return false;
+      }
+
+      if (
+        isPinged && 
+        !isOwnMessage && 
+        message.author.bot && 
+        !DyNTS_DiBo_global_settings.allowBotsInteractEachOther
+      ) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖❌ not for me; this message is from a bot')
+          message.reply('[SYSTEM|REFUSE|BOT] You should not ping me!')
+        }
+
+        return false;
+      }
+
+      if (!isPinged && !isOwnMessage && !isInDefaultChannel) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫 not for me; not pinged, and not my message, and not in default channel')
+        }
+
+        return false;
+      }
+
+      if (!isAllowedUser) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed user. END', message.author.username, message.author.displayName)
+          message.reply(
+            `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
+          )
+        }
+
+        return false;
+      }
+
+      if (!message.channel.isTextBased()) {
+        if (DyNTS_DiBo_global_settings.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not text based channel. END')
+        }
+
+        return false;
+      }
+      
+      return true;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getMessageIsForBotToHandle', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-MCS-G0`,
+      })
+    }
+  }
+
+  async handleIfCommand(message: Message, issuer: string): Promise<boolean> {
+    try {
+      const isCommand = await this.isCommand(message, issuer);
+
+      if (isCommand) {
+        await this.commands_CS.handleCommand(message, issuer);
+      }
+
+      return Boolean(isCommand);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleIfCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-IO-HIC0`,
+      })
+    }
+  }
+
+  async isCommand(message: Message, issuer: string): Promise<boolean> {
+    try {
+      let haveCommandOperator = false;
+
+      if (!DyNTS_DiBo_global_settings.commandSettings.commandOperator) {
+        haveCommandOperator = true;
+      } else if (
+        message.content.trim().startsWith(DyNTS_DiBo_global_settings.commandSettings.commandOperator)
+      ) {
+        haveCommandOperator = true;
+      }
+
+      if (!haveCommandOperator) {
+        return false;
+      }
+
+      const commandExists = DyNTS_DiBo_global_settings.commandSettings.commands.find(
+        (command) => message.content.trim().startsWith(
+          `${DyNTS_DiBo_global_settings.commandSettings.commandOperator}${command.command}`
+        )
+      );
+
+      return Boolean(commandExists);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('isCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-IO-IC0`,
+      })
+    }
+  }
+}