@futdevpro/nts-dynamo 1.10.77 → 1.11.1

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

@@ -0,0 +1,304 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel } from 'discord.js'
+import * as dotenv from 'dotenv'
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyFM_delay, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_Routines_ControlService } from './dibo-routines.control-service';
+import { DyNTS_DiBo_IO_ControlService } from './dibo-io.control-service';
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+import { DyNTS_DiBo_Operations_Util } from '../_collections/dibo-operations.util';
+
+
+/**
+ * This is the main control service for the Discord Bot.
+ * 
+ * 
+ * Setup:
+ * 1. creating the Bot
+ *   - go to: https://discord.com/developers/applications
+ *   - click: "New Application"
+ *   - give a name → Create
+ * 
+ * 2. adding the Bot to the app
+ *   - on the left: "Bot" → "Add Bot" → Yes, do it
+ * 
+ * 3. getting the token
+ *   - on the same page: "Reset Token" → Copy
+ *   - put the token in the .env file: DISCORD_TOKEN=...
+ * 
+ * 4. Bot ID (Client ID) and Invite link
+ *   - on the left: "OAuth2" > "URL Generator"
+ *   - Scopes: tick the bot
+ *   - Bot Permissions: pl. Send Messages, Read Message History
+ *   - at the bottom: generate Invite URL → open it → add it to a server
+ *   - the Client ID is on the same page, the "Application ID" on the "OAuth2 > General" or "Application" tab.
+ *   - it only works if you are admin on that server or have "Manage Server" permissions.
+ * 
+ * 5. Permissions
+ *   - on the left: "Bot" tab
+ *   - enable these:
+ *     - MESSAGE CONTENT INTENT
+ *     - PRESENCE INTENT (if you use it)
+ *     - SERVER MEMBERS INTENT (if you need guild user info)
+ *   - Save
+ * 
+ */
+export abstract class DyNTS_DiBo_Main_ControlService extends DyNTS_SingletonService {
+
+  /* static getInstance(): DyNTS_DiBo_Main_ControlService {
+    return DyNTS_DiBo_Main_ControlService.getSingletonInstance();
+  } */
+
+  readonly client: Client;
+
+  private _discordServer: Guild;
+  get discordServer(): Guild {
+    return this._discordServer;
+  }
+
+  get botClientId(): string {
+    return this.client.user?.id ?? DyNTS_global_settings.env_settings.discord.clientId;
+  }
+  get botDisplayName(): string {
+    return this.client.user?.displayName;
+  }
+
+  protected botIO_CS: DyNTS_DiBo_IO_ControlService;
+  protected abstract getBotIOControlService(): DyNTS_DiBo_IO_ControlService;
+  
+  protected routines_CS: DyNTS_DiBo_Routines_ControlService;
+  protected abstract getRoutinesControlService(): DyNTS_DiBo_Routines_ControlService;
+
+  private _channelsByNames: {
+    [key: string]: TextChannel;
+  } = {};
+
+  private _rolesByNames: {
+    [key: string]: Role;
+  } = {};
+  
+  protected debugLog = false;
+
+  protected constructor() {
+    super();
+
+    DyNTS_global_settings.bot_settings = DyNTS_DiBo_global_settings;
+
+    if (this.client) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'start', 
+          new Error('Discord client already initialized'), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-MCS-C000`,
+      })
+    }
+
+    this.client = new Client({
+      intents: DyNTS_global_settings.bot_settings.intents,
+      partials: DyNTS_global_settings.bot_settings.partials,
+    })
+    
+    this.setup('system-init');
+  }
+
+  async setup(issuer: string): Promise<void> {
+    try {
+      await DyFM_delay(100);
+
+      if (!DyNTS_global_settings.env_settings.discord.guildId) {
+        throw new Error(
+          `No discord server id found!` +
+          `\nPlease set the DISCORD_GUILD_ID in the .env file, ` +
+          `or directly in the DyNTS_global_settings.env_settings.discord.guildId` +
+          `\nYou also will need to set the DISCORD_TOKEN, DISCORD_CLIENT_ID and DISCORD_OAUTH2_URL.`
+        );
+      }
+
+      if (!DyNTS_global_settings.env_settings.discord.token) {
+        throw new Error(
+          `No discord token found!` +
+          `\nPlease set the DISCORD_TOKEN in the .env file, ` +
+          `or directly in the DyNTS_global_settings.env_settings.discord.token` +
+          `\nYou also will need to set the DISCORD_GUILD_ID, DISCORD_CLIENT_ID and DISCORD_OAUTH2_URL.`
+        );
+      }
+
+      if (!DyNTS_global_settings.env_settings.discord.clientId) {
+        throw new Error(
+          `No discord client id found!` +
+          `\nPlease set the DISCORD_CLIENT_ID in the .env file, ` +
+          `or directly in the DyNTS_global_settings.env_settings.discord.clientId` +
+          `\nYou also will need to set the DISCORD_GUILD_ID, DISCORD_TOKEN and DISCORD_OAUTH2_URL.`
+        );
+      }
+
+      if (!DyNTS_global_settings.env_settings.discord.oauth2Url) {
+        throw new Error(
+          `No discord oauth2 url found!` +
+          `\nPlease set the DISCORD_OAUTH2_URL in the .env file, ` +
+          `or directly in the DyNTS_global_settings.env_settings.discord.oauth2Url` +
+          `\nYou also will need to set the DISCORD_GUILD_ID, DISCORD_TOKEN and DISCORD_CLIENT_ID.`
+        );
+      }
+
+      DyNTS_DiBo_global_settings.channelSettings.defaultChannels.forEach(
+        channelName => {
+          if (!DyNTS_DiBo_global_settings.channelSettings.allowedChannels.includes(channelName)) {
+            DyNTS_DiBo_global_settings.channelSettings.allowedChannels.push(channelName);
+          }
+        }
+      );
+      if (!DyNTS_DiBo_global_settings.channelSettings.allowedChannels.includes(
+        DyNTS_DiBo_global_settings.channelSettings.reportChannelName
+      )) {
+        DyNTS_DiBo_global_settings.channelSettings.allowedChannels.push(
+          DyNTS_DiBo_global_settings.channelSettings.reportChannelName
+        );
+      }
+
+      return new Promise((resolve, reject) => {
+        this.client.on('error', (error) => {
+          if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
+            DyFM_Log.error('Discord client error:', error);
+          }
+          DyNTS_GlobalService.globalErrorHandler(error);
+          reject(error);
+        });
+
+        this.client.on('ready', async () => {
+          if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
+            DyFM_Log.success(`Logged in as ${this.client.user?.tag}`)
+          }
+          // szerver azonosító
+          this._discordServer = this.client.guilds.cache.get(
+            DyNTS_global_settings.env_settings.discord.guildId
+          ) 
+
+          if (!this._discordServer) {
+            throw new Error(`No discord server found`);
+          }
+
+          await this.start(issuer);
+
+          //await Operations.reportIn(this._discordServer, this.client)
+
+          resolve();
+        });
+
+        this.client.on('messageCreate', (message: Message) => {
+          try {
+            this.botIO_CS.handleNewMessage(message, message?.author?.id ?? 'unknown')
+          } catch (error) {
+            DyFM_Log.error('Error handling new message:', error);
+          }
+        });
+
+        process.on('exit', () => {
+          try {
+            DyFM_Log.warn('Bot is shutting down...')
+            DyNTS_DiBo_Operations_Util.sendMessageToChannelByName(
+              this._discordServer, 
+              DyNTS_DiBo_global_settings.channelSettings.reportChannelName, 
+              `Bot is shutting down...`
+            )
+          } catch (error) {
+            DyFM_Log.error('Error sending message to report channel:', error);
+          }
+        });
+
+        this.client.login(DyNTS_global_settings.env_settings.discord.token).catch((error) => {
+          reject(error);
+        });
+      });
+    } catch (error) {
+      if (this.discordServer) {
+        try {
+          DyNTS_DiBo_Operations_Util.sendMessageToChannelByName(
+            this.discordServer,
+            DyNTS_DiBo_global_settings.channelSettings.reportChannelName,
+            `#Error during bot startup:\n` +
+            ((error as DyFM_Error)._message ?? error.message ?? error)
+          )
+        } catch {}
+      }
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode:  `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-MCS-SE0`,
+      })
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      this.botIO_CS = this.getBotIOControlService();
+      this.routines_CS = this.getRoutinesControlService();
+
+      await this.routines_CS.start(issuer);
+
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode:  `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-MCS-ST0`,
+      })
+    }
+  }
+
+  async getRolePingByName(roleName: string): Promise<string> {
+    const role: Role = this.getRoleByName(roleName);
+
+    return role ? `<@&${role.id}>` : '';
+  }
+
+  async getRolePingsByName(roleNames: string[]): Promise<string> {
+    const pings: string[] = await Promise.all(
+      roleNames.map(roleName => this.getRolePingByName(roleName))
+    );
+
+    return pings.join(' ');
+  }
+
+  getRoleByName(roleName: string): Role {
+    this._rolesByNames[roleName] ??= this.discordServer.roles.cache.find(r => r.name === roleName);
+    
+    return this._rolesByNames[roleName];
+  }
+
+  getChannelByName(channelName: string): TextChannel {
+    this._channelsByNames[channelName] ??= DyNTS_DiBo_Operations_Util.findTextChannelByName(
+      this.discordServer.channels,
+      channelName
+    );
+
+    return this._channelsByNames[channelName];
+  }
+}
+
+/**
+ * A leggyakoribb client.on(...) események a következők (TypeScript + discord.js 14+):
+ * 
+ * 🔁 Alap események
+ * client.on('ready', () => {})               // Bot elindult
+ * client.on('messageCreate', (msg) => {})    // Üzenet érkezett
+ * client.on('interactionCreate', (i) => {})  // Slash command vagy gomb stb.
+ * client.on('guildCreate', (guild) => {})    // Új szerverre került
+ * client.on('guildDelete', (guild) => {})    // Szerverről eltávolították
+ * client.on('error', (err) => {})            // Hiba történt
+ * 
+ * 👥 Felhasználókkal kapcsolatos események
+ * client.on('guildMemberAdd', (member) => {})    // Új user csatlakozott
+ * client.on('guildMemberRemove', (member) => {}) // User kilépett
+ * client.on('presenceUpdate', (oldP, newP) => {})// Status változott (pl. online → idle)
+ * ✏️ Üzenet események
+ * client.on('messageUpdate', (oldMsg, newMsg) => {}) // Üzenet módosult
+ * client.on('messageDelete', (msg) => {})            // Üzenetet töröltek
+ * 
+ * 🔧 Moderáció/jogosultság/stb.
+ * client.on('roleCreate', (role) => {})
+ * client.on('roleDelete', (role) => {})
+ * client.on('channelCreate', (ch) => {})
+ * client.on('channelDelete', (ch) => {})
+ */

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

@@ -0,0 +1,60 @@
+import { timer, of, Subscription } from 'rxjs';
+import { switchMap, filter, tap } from 'rxjs/operators';
+import { Guild } from 'discord.js';
+
+import { day, DyFM_delay, DyFM_Error, hour, minute } 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';
+
+export abstract class DyNTS_DiBo_Routines_ControlService extends DyNTS_SingletonService {
+
+  static getInstance(): DyNTS_DiBo_Routines_ControlService {
+    return DyNTS_DiBo_Routines_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 DiscordBot_ControlService.start'
+          ), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-RCS-C000`,
+      })
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      await this.startRoutines(issuer);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-RCS-ST0`,
+      })
+    }
+  }
+
+  abstract startRoutines(issuer: string): Promise<void>;
+}
+
+
+
+
+

package/src/_modules/discord-bot/index.ts

@@ -0,0 +1,36 @@
+
+
+
+
+try {
+  require('discord.js');
+} catch (error) {
+  console.log(
+    '❌ Discord.js package not found, please install it with: pnpm add discord.js'
+  );
+}
+
+//
+// Discord Bot module
+//
+// This module is created to simplify the usage of Discord Bot
+// It creates universal solutions for the most common use cases
+//
+
+
+// COLLECTIONS
+export * from './_collections/dibo-default-commands.const';
+export * from './_collections/dibo-global-settings.conts';
+export * from './_collections/dibo-operations.util';
+
+// MODELS
+export * from './_models/dibo-command.interface';
+export * from './_models/dibo-last-mention-date.inteface';
+export * from './_models/dibo-last-message-date.interface';
+export * from './_models/global-bot-log-settings.interface';
+
+// SERVICES
+export * from './_services/dibo-commands.control-service';
+export * from './_services/dibo-io.control-service';
+export * from './_services/dibo-main.control-service';
+export * from './_services/dibo-routines.control-service';

package/src/_modules/oauth2/index.ts

@@ -1,4 +1,12 @@
+try {
+  require('crypto');
+} catch (error) {
+  console.log(
+    '❌ CryptoJS package not found, please install it with: pnpm add crypto-js'
+  );
+}
 
+// This module is implementing solutions for OAuth2.0 protocol for the server.
 
 
 export * from './_routes/oauth2.controller';