@futdevpro/nts-dynamo 1.14.8 → 1.14.9

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

@@ -0,0 +1,325 @@
+import { DyFM_Error, DyFM_Log, hour, week } from '@futdevpro/fsm-dynamo'
+import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service'
+import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service'
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service'
+import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service'
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const'
+import { DyNTS_Bot_Message } from '../_models/bot-message.interface'
+import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface'
+import { DyNTS_Bot_User } from '../_models/bot-user.interface'
+import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface'
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface'
+import { DyNTS_Msg_Integration_ControlService } from '../../messaging/_services/msg-integration.control-service'
+
+export abstract class DyNTS_Bot_IO_ControlService<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+> extends DyNTS_SingletonService {
+
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+  protected abstract mainBot_CS: DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+
+  get provider(): T_PlatformProvider {
+    return this.mainBot_CS?.provider;
+  }
+  
+  get botClientId(): string {
+    return this.mainBot_CS.botClientId;
+  }
+  
+  get botDisplayName(): string {
+    return this.mainBot_CS.botDisplayName;
+  }
+
+  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
+  protected commands_CS: DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
+
+  dontSendErrorReply?: boolean;
+
+  async start(issuer: string): Promise<void> {
+    try {
+      this.mainBot_CS = this.getMainBotControlService();
+      this.commands_CS = this.getCommandsControlService();
+
+      if (!this.provider) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'constructor', 
+            new Error(
+              'Bot provider not yet initialized, ' +
+              'should only be called after DyNTS_Bot_Main_ControlService.start'
+            ), 
+            'system-init'
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-C000`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-S000`,
+      })
+    }
+  }
+
+  async handleNewMessage(message: T_PlatformMessage, issuer: string): Promise<void> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (botSettings?.debugLevel >= 1) {
+        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}):\n${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);
+      
+      // Sync message to messaging system if enabled
+      try {
+        if (DyNTS_global_settings.messaging_settings?.integration?.syncBotMessages) {
+          const messagingIntegration = DyNTS_Msg_Integration_ControlService.getInstance();
+          
+          // Find or create conversation for this channel
+          const conversation = await messagingIntegration.findOrCreateBotConversation(
+            message.channelId,
+            this.provider.getProviderName(),
+            issuer
+          );
+          
+          // Sync the message
+          await messagingIntegration.syncBotMessage(
+            message,
+            conversation._id!,
+            issuer
+          );
+        }
+      } catch (syncError) {
+        // Log sync error but don't break bot functionality
+        DyFM_Log.error('Failed to sync bot message to messaging system', syncError);
+      }
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error handleNewMessage:', error);
+
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (!this.dontSendErrorReply && botSettings?.debugLevel >= 1) {
+        await this.provider.replyToMessage(
+          message.id,
+          message.channelId,
+          `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] 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-Bot-MCS-H0`,
+      })
+    }
+  }
+
+  abstract handleMessage(message: T_PlatformMessage, issuer: string): Promise<T_PlatformMessage>;
+
+  async getMessageIsForBotToHandle(
+    message: T_PlatformMessage, 
+    issuer: string, 
+    dontRemovePing?: boolean
+  ): Promise<boolean> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+        DyFM_Log.H_error(
+          '🚫❌ Bot not initialized yet. END wont respond to message:', message.content,
+          new Error('Bot not initialized yet').stack
+        )
+
+        await this.start(issuer);
+
+        if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+          DyFM_Log.H_error(
+            '🚫❌❌ can not start bot. END wont respond to message:', message.content,
+            new Error('can not start bot').stack
+          )
+        }
+
+        return false;
+      }
+
+      const isReplyForYou = message.replyToMessageId && message.replyToMessageId; // Simplified check
+      const isPinged = message.content.includes(this.botClientId) || 
+        message.content.includes(`@${this.botDisplayName}`) ||
+        isReplyForYou;
+      const isOwnMessage = message.authorId === this.botClientId || 
+        message.authorDisplayName === this.botDisplayName;
+      const haveSkipFlags = botSettings?.messageSettings?.skipFlags?.some(
+        flag => message.content.includes(flag)
+      ) || false;
+      const channelName = message.channelName;
+      const isDMChannel = message.channelName?.startsWith('DM-'); // Simplified DM detection
+      const isInDefaultChannel = botSettings?.channelSettings?.defaultChannels?.includes(
+        channelName
+      ) || (isDMChannel && botSettings?.channelSettings?.dmIsAllowed);
+      const isAllowedChannel = botSettings?.channelSettings?.allowedChannels?.includes(
+        channelName
+      ) || (isDMChannel && botSettings?.channelSettings?.dmIsAllowed);
+
+      if (!isAllowedChannel) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed channel. END')
+        }
+
+        if (!isOwnMessage && isPinged) {
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            `[SYSTEM|REFUSE|CHANNEL] I'm sorry, but I'm not allowed to answer you in this channel!`
+          )
+        }
+
+        return false;
+      }
+      
+      if (isOwnMessage) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖 will not answer; own message')
+        }
+
+        return false;
+      }
+
+      if (haveSkipFlags) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🏳️  not for me; this message have some skip flags:', 
+            botSettings?.messageSettings?.skipFlags?.filter(
+              flag => message.content.includes(flag)
+            ),
+            message.content
+          )
+        }
+
+        return false;
+      }
+
+      if (
+        message.isBot && 
+        !botSettings?.allowBotsInteractEachOther
+      ) {
+        if (isPinged && botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖❌ not for me; this message is from a bot')
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            '[SYSTEM|REFUSE|BOT] You should not ping me!'
+          )
+        }
+
+        return false;
+      }
+
+      if (!isPinged && !isInDefaultChannel) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫 not for me; not pinged, and not my message, and not in default channel')
+        }
+
+        return false;
+      }
+
+      const isAllowedUser = botSettings?.allowedUsers === 'all' || 
+        botSettings?.allowedUsers?.includes(message.authorId) ||
+        botSettings?.allowedUsers?.includes(message.authorName) ||
+        botSettings?.allowedUsers?.includes(message.authorDisplayName);
+
+      if (!isAllowedUser) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed user. END', message.authorName, message.authorDisplayName)
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
+          )
+        }
+
+        return false;
+      }
+
+      if (!message.channelName) {
+        if (botSettings?.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-Bot-MCS-G0`,
+      })
+    }
+  }
+
+  async handleIfCommand(message: T_PlatformMessage, 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-Bot-IO-HIC0`,
+      })
+    }
+  }
+
+  async isCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      let haveCommandOperator = false;
+
+      if (!botSettings?.commandSettings?.commandOperator) {
+        haveCommandOperator = true;
+      } else if (
+        message.content.trim().startsWith(botSettings.commandSettings.commandOperator)
+      ) {
+        haveCommandOperator = true;
+      }
+
+      if (!haveCommandOperator) {
+        return false;
+      }
+
+      const commandExists = botSettings?.commandSettings?.commands?.find(
+        (command) => message.content.trim().startsWith(
+          `${botSettings.commandSettings.commandOperator}${command.command}`
+        )
+      );
+
+      return Boolean(commandExists);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('isCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-IC0`,
+      })
+    }
+  }
+}

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

@@ -0,0 +1,344 @@
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyFM_Async, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
+import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
+import { DyNTS_Bot_User } from '../_models/bot-user.interface';
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
+import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
+
+/**
+ * This is the main control service for the Bot.
+ * 
+ * Platform-agnostic bot service that works with any provider (Discord, Slack, Teams, etc.)
+ * 
+ * Setup:
+ * 1. Configure provider in DyNTS_global_settings.bot_settings
+ * 2. Set provider type and credentials
+ * 3. Initialize the bot with setup()
+ */
+
+export abstract class DyNTS_Bot_Main_ControlService<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  >
+> extends DyNTS_SingletonService {
+
+  protected _provider: T_PlatformProvider;
+
+  get provider(): T_PlatformProvider {
+    return this._provider;
+  }
+
+  get botClientId(): string {
+    return this.provider?.getBotId() ?? DyNTS_global_settings?.bot_settings?.discord?.clientId;
+  }
+  
+  get botDisplayName(): string {
+    return this.provider?.getBotDisplayName();
+  }
+
+  protected abstract getBotIOControlService(): DyNTS_Bot_IO_ControlService<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser, 
+    T_PlatformProvider
+  >;
+  protected botIO_CS: DyNTS_Bot_IO_ControlService<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser, 
+    T_PlatformProvider
+  >;
+  
+  protected abstract getRoutinesControlService(): DyNTS_Bot_Routines_ControlService<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser, 
+    T_PlatformProvider
+  >;
+  protected routines_CS: DyNTS_Bot_Routines_ControlService<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser, 
+    T_PlatformProvider
+  >;
+
+  protected abstract getProvider(): T_PlatformProvider;
+
+  private _channelsByNames: {
+    [key: string]: T_PlatformChannel;
+  } = {};
+
+  private _rolesByNames: {
+    [key: string]: any;
+  } = {};
+  
+  protected debugLog = false;
+
+  protected constructor(
+    setupAutomatically?: boolean,
+  ) {
+    super();
+
+    if (this.provider) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'start', 
+          new Error('Bot provider already initialized'), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-C000`,
+      })
+    }
+
+    this._provider = this.getProvider();
+    DyFM_Log.success('Bot provider initialized');
+    
+    if (setupAutomatically) {
+      this.setup('system-init');
+    }
+  }
+
+  async setup(issuer: string): Promise<void> {
+    try {
+      await DyFM_Async.delay(100);
+
+      if (!DyNTS_global_settings.bot_settings?.provider) {
+        throw new Error(
+          `No bot provider configured!` +
+          `\nPlease set the provider in DyNTS_global_settings.bot_settings.provider` +
+          `\nSupported providers: 'discord', 'slack', 'teams', 'custom'`
+        );
+      }
+
+      if (!this.provider) {
+        throw new Error(
+          `No bot provider instance found!` +
+          `\nPlease ensure getProvider() returns a valid provider instance`
+        );
+      }
+
+      return new Promise((resolve, reject) => {
+        this.provider.onError((error) => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Error.logSimple('Bot provider error:', error);
+          }
+          DyNTS_GlobalService.globalErrorHandler(error);
+          reject(error);
+        });
+        
+        if (this.debugLog) {
+          DyFM_Log.success('Error event registered\n\n', new Error().stack);
+        } else {
+          DyFM_Log.success('Error event registered');
+        }
+
+        this.provider.onReady(async () => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Log.success(`Bot logged in as ${this.botDisplayName}`)
+          }
+
+          await this.start(issuer);
+
+          DyFM_Log.success('Bot setup complete')
+          resolve();
+        });
+
+        if (this.debugLog) {
+          DyFM_Log.success('Ready event registered\n\n', new Error().stack);
+        } else {
+          DyFM_Log.success('Ready event registered');
+        }
+
+        this.provider.onMessage((message: T_PlatformMessage, messageIssuer: string) => {
+          try {
+            this.botIO_CS.handleNewMessage(message, messageIssuer)
+          } catch (error) {
+            DyFM_Error.logSimple('Error handling new message:', error);
+          }
+        });
+
+        if (this.debugLog) {
+          DyFM_Log.success('Message create event registered\n\n', new Error().stack);
+        } else {
+          DyFM_Log.success('Message create event registered');
+        }
+
+        process.on('exit', () => {
+          try {
+            DyFM_Log.warn('Bot is shutting down...')
+            this.sendMessageToChannelByName(
+              DyNTS_global_settings.bot_settings?.channelSettings?.reportChannelName || 'bot-reports', 
+              `Bot is shutting down...`,
+              'system-shutdown'
+            )
+          } catch (error) {
+            DyFM_Error.logSimple('Error sending message to report channel:', error);
+          }
+        });
+
+        if (this.debugLog) {
+          DyFM_Log.success('Exit event registered\n\n', new Error().stack);
+        } else {
+          DyFM_Log.success('Exit event registered');
+        }
+
+        // Initialize and login the provider
+        this.provider.initialize(DyNTS_global_settings.bot_settings).then(() => {
+          const token = this.getTokenForProvider();
+          return this.provider.login(token);
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    } catch (error) {
+      DyFM_Error.logSimple('Error during bot startup:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode:  `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SE0`,
+      })
+    }
+  }
+
+  private getTokenForProvider(): string {
+    const provider = DyNTS_global_settings.bot_settings?.provider;
+    switch (provider) {
+      case 'discord':
+        return DyNTS_global_settings.bot_settings?.discord?.token;
+      case 'slack':
+        return DyNTS_global_settings.bot_settings?.slack?.token;
+      case 'teams':
+        return DyNTS_global_settings.bot_settings?.teams?.appPassword;
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      this.botIO_CS = this.getBotIOControlService();
+      this.routines_CS = this.getRoutinesControlService();
+
+      await this.routines_CS.start(issuer);
+      await this.botIO_CS.start(issuer);
+
+      DyFM_Log.success('Bot started')
+    } catch (error) {
+      DyFM_Error.logSimple('Error during bot start:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode:  `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-ST0`,
+      })
+    }
+  }
+
+  async getRolePingByName(roleName: string): Promise<string> {
+    const role = this.getRoleByName(roleName);
+
+    return role ? await this.provider.getRolePingByName?.(roleName) || '' : '';
+  }
+
+  async getRolePingsByName(roleNames: string[]): Promise<string> {
+    const pings: string[] = await Promise.all(
+      roleNames.map(roleName => this.getRolePingByName(roleName))
+    );
+
+    return pings.join(' ');
+  }
+
+  getRoleByName(roleName: string): any {
+    this._rolesByNames[roleName] ??= this.provider.getRoleByName?.(roleName);
+    
+    return this._rolesByNames[roleName];
+  }
+
+  async getChannelByName(channelName: string): Promise<T_PlatformChannel> {
+    if (!this._channelsByNames[channelName]) {
+      this._channelsByNames[channelName] = await this.provider.getChannelByName(channelName);
+    }
+
+    return this._channelsByNames[channelName];
+  }
+  
+  async sendMessageToChannelByName(
+    channelName: string,
+    message: string,
+    issuer: string,
+  ): Promise<T_PlatformMessage> {
+    try {
+      const channel = await this.getChannelByName(channelName);
+
+      if (!channel) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'sendMessageToChannelByName',
+            new Error('Channel not found'), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SMCN1`,
+        })
+      }
+
+      if (!channel.isTextBased) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'sendMessageToChannelByName', 
+            new Error('Channel is not a text channel'), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SMCN2`,
+        })
+      }
+
+      return await this.provider.sendMessageToChannelByName(channelName, message);
+    } catch (error) {
+      DyFM_Error.logSimple('Error sending message to channel by name:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('sendMessageToChannelByName', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SMCN0`,
+      })
+    }
+  }
+
+  async clearChannel(
+    channel: T_PlatformChannel,
+    issuer: string,
+  ): Promise<void> {
+    try {
+      DyFM_Log.testInfo('Clearing channel... ', channel.name);
+
+      await this.provider.clearChannel(channel.id);
+
+      DyFM_Log.success('Channel cleared');
+
+      this.sendMessageToChannelByName(
+        channel.name,
+        '[SYSTEM|OPERATION|RESULT] Channel messages deletion completed successfully.',
+        issuer
+      );
+    } catch (error) {
+      DyFM_Error.logSimple('Error clearing channel:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('clearChannel', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-CC0`,
+      })
+    }
+  }
+}

package/src/_modules/bot/_services/bot-provider-factory.service.ts

@@ -0,0 +1,30 @@
+import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_Provider_Type } from '../_enums/bot-provider.enum';
+import { DyNTS_DiB_Provider } from '../_modules/discord-bot/_services/dib-provider.service';
+import { DyNTS_SlB_Provider } from '../_modules/slack-bot/_services/slb-provider.service';
+import { DyNTS_TeB_Provider } from '../_modules/teams-bot/_services/teb-provider.service';
+
+export class DyNTS_Bot_Provider_Factory {
+
+  static createProvider(config: DyNTS_Bot_Provider_Config): DyNTS_Bot_Provider {
+    switch (config.provider) {
+      case DyNTS_Bot_Provider_Type.discord:
+        return new DyNTS_DiB_Provider();
+
+      case DyNTS_Bot_Provider_Type.slack:
+        return new DyNTS_SlB_Provider();
+
+      case DyNTS_Bot_Provider_Type.teams:
+        return new DyNTS_TeB_Provider();
+
+      case DyNTS_Bot_Provider_Type.custom:
+        if (!config.providerInstance) {
+          throw new Error('Custom provider instance is required when provider type is "custom"');
+        }
+        return config.providerInstance;
+
+      default:
+        throw new Error(`Unsupported provider type: ${config.provider}`);
+    }
+  }
+}