@futdevpro/nts-dynamo 1.14.29 → 1.14.32

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

@@ -1,16 +1,16 @@
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyFM_Async, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../_models/bot-messaging-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, DyNTS_Bot_Settings } from '../_models/bot-global-settings.interface';
 import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_MessagingProvider_Type } from '../_enums/bot-message-provider.enum';
+
 import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
 import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_MessagingProvider_Factory } from './bot-messaging-provider-factory.service';
+import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service';
 
 /**
  * This is the main control service for the Bot.
@@ -24,136 +24,63 @@ import { DyNTS_Bot_MessagingProvider_Factory } from './bot-messaging-provider-fa
  */
 
 export abstract class DyNTS_Bot_Main_ControlService<
-  T_MessagingPlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
-  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  T_MessagingPlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_MessagingPlatformProvider extends DyNTS_Bot_MessagingProvider<
-    T_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser
-  > = DyNTS_Bot_MessagingProvider<
-    T_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser
-  >
+  T_MessagingPlatformProvider_Type extends DyNTS_Bot_MessagingProvider_Type | string = DyNTS_Bot_MessagingProvider_Type,
 > extends DyNTS_SingletonService {
 
-  protected _provider: T_MessagingPlatformProvider;
-  protected _providers: Map<string, T_MessagingPlatformProvider> = new Map();
+  //protected _provider: DyNTS_Bot_MessagingProvider<any, any, any>;
+  protected _providers: Map<
+    T_MessagingPlatformProvider_Type, 
+    DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>
+  > = new Map();
 
-  get provider(): T_MessagingPlatformProvider {
-    return this._provider;
+  protected _defaultProvider: DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>;
+  get defaultProvider(): DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any> {
+    return this._defaultProvider;
   }
 
-  get providers(): Map<string, T_MessagingPlatformProvider> {
+  /* get provider(): DyNTS_Bot_MessagingProvider<any, any, any> {
+    return this._provider;
+  } */
+
+  /* get providers(): Map<string, DyNTS_Bot_MessagingProvider<any, any, any>> {
     return this._providers;
-  }
+  } */
 
-  getProviderById(providerId: string): T_MessagingPlatformProvider | undefined {
+  /* getProviderById(providerId: string): DyNTS_Bot_MessagingProvider<any, any, any> | undefined {
     return this._providers.get(providerId);
-  }
+  } */
 
-  get botClientId(): string {
+  /* 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_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser, 
-    T_MessagingPlatformProvider
-  >;
-  protected botIO_CS: DyNTS_Bot_IO_ControlService<
-    T_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser, 
-    T_MessagingPlatformProvider
-  >;
+  botIO_CS: DyNTS_Bot_IO_ControlService;
+  protected abstract getBotIOControlService(): DyNTS_Bot_IO_ControlService;
   
-  protected abstract getRoutinesControlService(): DyNTS_Bot_Routines_ControlService<
-    T_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser, 
-    T_MessagingPlatformProvider
-  >;
-  protected routines_CS: DyNTS_Bot_Routines_ControlService<
-    T_MessagingPlatformChannel, 
-    T_MessagingPlatformMessage, 
-    T_MessagingPlatformUser, 
-    T_MessagingPlatformProvider
-  >;
-
-  protected abstract getProvider(): T_MessagingPlatformProvider;
-
-  private _channelsByNames: {
-    [key: string]: T_MessagingPlatformChannel;
-  } = {};
-
-  private _rolesByNames: {
-    [key: string]: any;
-  } = {};
+  routines_CS: DyNTS_Bot_Routines_ControlService;
+  protected abstract getRoutinesControlService(): DyNTS_Bot_Routines_ControlService;
+
+  commands_CS: DyNTS_Bot_Commands_ControlService;
+  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService;
+  
+  protected abstract defaultProviderType: T_MessagingPlatformProvider_Type;
+  protected abstract availableProviders: DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>[];
   
   protected debugLog = false;
 
-  protected constructor(
-    setupAutomatically?: boolean,
-  ) {
+  /* protected constructor() {
     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');
-    }
-  }
-
-  /**
-   * Check if the bot is configured for multiple providers
-   */
-  protected isMultiProviderMode(): boolean {
-    const settings = DyNTS_global_settings.bot_settings as any;
-    return Array.isArray(settings?.providers) && settings.providers.length > 0;
-  }
-
-  /**
-   * Get all provider configurations (supports both single and multi-provider mode)
-   */
-  protected getProviderConfigs(): DyNTS_Bot_MessagingProvider_Config[] {
-    const settings = DyNTS_global_settings.bot_settings as any;
-    
-    if (this.isMultiProviderMode()) {
-      return settings.providers;
-    } else {
-      // Single provider mode - wrap existing config
-      const config = settings as DyNTS_Bot_MessagingProvider_Config;
-      if (!config.providerId) {
-        config.providerId = config.messageProvider || 'default';
-      }
-      return [config];
-    }
-  }
+  } */
 
   async setup(issuer: string): Promise<void> {
     try {
       await DyFM_Async.delay(100);
 
-      const configs = this.getProviderConfigs();
+      /* const configs = this.getProviderConfigs();
       
       if (configs.length === 0) {
         throw new Error(
@@ -161,102 +88,74 @@ export abstract class DyNTS_Bot_Main_ControlService<
           `\nPlease set the provider in DyNTS_global_settings.bot_settings.provider` +
           `\nSupported providers: 'discord', 'slack', 'teams', 'custom'`
         );
+      } */
+
+      if (this.availableProviders.length === 0) {
+        throw new Error(
+          `No bot providers configured!` +
+          `\nPlease set the providers in DyNTS_global_settings.bot_settings.providers`
+        );
       }
 
-      // If multi-provider mode, initialize all providers
-      if (this.isMultiProviderMode()) {
-        await this.setupMultipleProviders(configs, issuer);
-        return;
+      if (!this.defaultProviderType) {
+        throw new Error(
+          `No default bot provider type configured!` +
+          `\nPlease set the default provider type in DyNTS_global_settings.bot_settings.defaultProviderType`
+        );
       }
 
-      // Single provider mode (backward compatible)
-      if (!this.provider) {
+      if (!this.availableProviders.find(provider => provider.type === this.defaultProviderType)) {
         throw new Error(
-          `No bot provider instance found!` +
-          `\nPlease ensure getProvider() returns a valid provider instance`
+          `Default bot provider type not found in available providers!` +
+          `\nPlease set the default provider type in DyNTS_global_settings.bot_settings.defaultProviderType`
         );
       }
 
-      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.botIO_CS = this.getBotIOControlService();
+      this.routines_CS = this.getRoutinesControlService();
+      this.commands_CS = this.getCommandsControlService();
 
-        this.provider.onReady(async () => {
-          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
-            DyFM_Log.success(`Bot logged in as ${this.botDisplayName}`)
-          }
+      if (!this.botIO_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Bot IO Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-S01`,
+        })
+      }
 
-          await this.start(issuer);
+      if (!this.routines_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Routines Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-S02`,
+        })
+      }
 
-          DyFM_Log.success('Bot setup complete')
-          resolve();
-        });
+      if (!this.commands_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Commands Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-S03`,
+        })
+      }
 
-        if (this.debugLog) {
-          DyFM_Log.success('Ready event registered\n\n', new Error().stack);
-        } else {
-          DyFM_Log.success('Ready event registered');
-        }
+      await this.botIO_CS.setup(issuer);
+      await this.routines_CS.setup(issuer);
+      await this.commands_CS.setup(issuer);
 
-        this.provider.onMessage((message: T_MessagingPlatformMessage, messageIssuer: string) => {
-          try {
-            const wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage> = {
-              message: message,
-              providerId: 'default',
-              providerType: this.provider.getProviderName() as any,
-              provider: this.provider
-            };
-            
-            this.botIO_CS.handleNewMessage(wrapper, messageIssuer)
-          } catch (error) {
-            DyFM_Error.logSimple('Error handling new message:', error);
-          }
-        });
+      for (const provider of this.availableProviders) {
+        await this.setupProvider(provider, issuer);
+        this._providers.set(provider.type as T_MessagingPlatformProvider_Type, provider);
+      }
 
-        if (this.debugLog) {
-          DyFM_Log.success('Message create event registered\n\n', new Error().stack);
-        } else {
-          DyFM_Log.success('Message create event registered');
-        }
+      this._defaultProvider = this.getProviderByType(this.defaultProviderType);
 
-        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);
-          }
-        });
+      await this.commands_CS.start(issuer);
+      await this.routines_CS.start(issuer);
+      await this.botIO_CS.start(issuer);
 
-        if (this.debugLog) {
-          DyFM_Log.success('Exit event registered\n\n', new Error().stack);
-        } else {
-          DyFM_Log.success('Exit event registered');
-        }
+      for (const provider of this.availableProviders) {
+        await provider.start(issuer);
+      }
 
-        // 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);
-        });
-      });
+      DyFM_Log.H_success('Bot setup complete')
     } catch (error) {
       DyFM_Error.logSimple('Error during bot startup:', error);
 
@@ -267,26 +166,145 @@ export abstract class DyNTS_Bot_Main_ControlService<
     }
   }
 
-  private getTokenForProvider(): string {
+  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 setupProvider(provider: DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>, issuer: string): Promise<void> {
+    try {
+      await provider.setup(issuer);
+
+      provider.create_onErrorEventListener((error) => {
+        if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+          DyFM_Error.logSimple(`${provider.name} provider error:`, error);
+        }
+        DyNTS_GlobalService.globalErrorHandler(error);
+      });
+      
+      if (this.debugLog) {
+        DyFM_Log.success(`${provider.name} Error event registered\n\n`, new Error().stack);
+      } else {
+        DyFM_Log.success(`${provider.name} Error event registered`);
+      }
+
+      provider.create_onMessageEventListener((message: DyNTS_Bot_MessageWrapper<any>, messageIssuer: string) => {
+        try {
+          this.botIO_CS._handleNewMessage(message, messageIssuer)
+        } catch (error) {
+          DyFM_Error.logSimple(`${provider.name} error handling new message:`, error);
+          DyNTS_GlobalService.globalErrorHandler(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...')
+          provider.sendMessageToChannelByName(
+            provider.config.reportChannelName || 'bot-reports', 
+            `Bot is shutting down...`,
+            'system-shutdown'
+          )
+        } catch (error) {
+          DyFM_Error.logSimple(`${provider.name} error sending message to report channel:`, error);
+          DyNTS_GlobalService.globalErrorHandler(error);
+        }
+      });
+
+      if (this.debugLog) {
+        DyFM_Log.success('Exit event registered\n\n', new Error().stack);
+      } else {
+        DyFM_Log.success('Exit event registered');
+      }
+    } catch (error) {
+      DyFM_Error.logSimple('Error during bot provider setup:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(`setupProvider ${provider.name}`, error, issuer),
+        errorCode:  `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SPS0`,
+      })
+    }
+  }
+
+  getProviderByType<
+    T_MessagingPlatformProvider extends DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>
+  >(type: T_MessagingPlatformProvider_Type): T_MessagingPlatformProvider {
+    return this._providers.get(type) as T_MessagingPlatformProvider;
+  }
+
+  async sendReport(message: string): Promise<void> {
+    await this.defaultProvider.sendReport(message);
+  }
+
+  /**
+   * Check if the bot is configured for multiple providers
+   */
+  /* protected isMultiProviderMode(): boolean {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    return Array.isArray(settings?.providers) && settings.providers.length > 0;
+  } */
+
+  /**
+   * Get all provider configurations (supports both single and multi-provider mode)
+   */
+  /* protected getProviderConfigs(): DyNTS_Bot_MessagingProvider_Config[] {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    
+    if (this.isMultiProviderMode()) {
+      return settings.providers;
+    } else {
+      // Single provider mode - wrap existing config
+      const config = settings as DyNTS_Bot_MessagingProvider_Config;
+      if (!config.messagingProviderId) {
+        config.messagingProviderId = config.messagingProvider || 'default';
+      }
+      return [config];
+    }
+  } */
+
+  /* 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}`);
     }
-  }
+  } */
 
-  private async setupMultipleProviders(
+  /* private async setupMultipleProviders(
     configs: DyNTS_Bot_MessagingProvider_Config[], 
     issuer: string
   ): Promise<void> {
     const providers = DyNTS_Bot_MessagingProvider_Factory.createProviders(configs);
-    this._providers = providers as Map<string, T_MessagingPlatformProvider>;
+    this._providers = providers as Map<string, DyNTS_Bot_MessagingProvider<any, any, any>>;
 
     const setupPromises = Array.from(providers.entries()).map(([providerId, provider]) => {
       return new Promise<void>((resolve, reject) => {
@@ -307,8 +325,8 @@ export abstract class DyNTS_Bot_Main_ControlService<
 
         provider.onMessage((message, messageIssuer, msgProviderId) => {
           try {
-            const wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage> = {
-              message: message as T_MessagingPlatformMessage,
+            const wrapper: DyNTS_Bot_MessageWrapper<any> = {
+              message: message,
               providerId: msgProviderId || provider.getProviderId() || providerId,
               providerType: provider.getProviderName() as any,
               provider: provider as any
@@ -320,7 +338,7 @@ export abstract class DyNTS_Bot_Main_ControlService<
           }
         });
 
-        const config = configs.find(c => c.providerId === providerId);
+        const config = configs.find(c => c.messagingProviderId === providerId);
         if (!config) {
           reject(new Error(`No config found for provider ${providerId}`));
           return;
@@ -345,10 +363,10 @@ export abstract class DyNTS_Bot_Main_ControlService<
     await this.start(issuer);
     
     DyFM_Log.success('All bot providers setup complete');
-  }
+  } */
 
-  private getTokenForProviderConfig(config: DyNTS_Bot_MessagingProvider_Config): string {
-    switch (config.messageProvider) {
+  /* private getTokenForProviderConfig(config: DyNTS_Bot_MessagingProvider_Config): string {
+    switch (config.messagingProvider) {
       case 'discord':
         return config.discord?.token;
       case 'slack':
@@ -356,30 +374,11 @@ export abstract class DyNTS_Bot_Main_ControlService<
       case 'teams':
         return config.teams?.appPassword;
       default:
-        throw new Error(`Unsupported provider: ${config.messageProvider}`);
-    }
-  }
-
-  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`,
-      })
+        throw new Error(`Unsupported provider: ${config.messagingProvider}`);
     }
-  }
+  } */
 
-  async getRolePingByName(roleName: string): Promise<string> {
+  /* async getRolePingByName(roleName: string): Promise<string> {
     const role = this.getRoleByName(roleName);
 
     return role ? await this.provider.getRolePingByName?.(roleName) || '' : '';
@@ -397,23 +396,30 @@ export abstract class DyNTS_Bot_Main_ControlService<
     this._rolesByNames[roleName] ??= this.provider.getRoleByName?.(roleName);
     
     return this._rolesByNames[roleName];
-  }
+  } */
 
-  async getChannelByName(channelName: string): Promise<T_MessagingPlatformChannel> {
+ /*  async getChannelByName(channelName: string): Promise<DyNTS_Bot_ChannelWrapper<any>> {
     if (!this._channelsByNames[channelName]) {
-      this._channelsByNames[channelName] = await this.provider.getChannelByName(channelName);
+      const channel = await this.provider.getChannelByName(channelName);
+      this._channelsByNames[channelName] = {
+        channel: channel,
+        providerId: this.provider.getProviderId(),
+        providerType: this.provider.getProviderName() as any,
+        provider: this.provider
+      };
     }
 
     return this._channelsByNames[channelName];
-  }
+  } */
   
-  async sendMessageToChannelByName(
+  /* async sendMessageToChannelByName(
     channelName: string,
     message: string,
     issuer: string,
-  ): Promise<T_MessagingPlatformMessage> {
+  ): Promise<DyNTS_Bot_MessageWrapper<any>> {
     try {
-      const channel = await this.getChannelByName(channelName);
+      const channelWrapper = await this.getChannelByName(channelName);
+      const channel = channelWrapper.channel;
 
       if (!channel) {
         throw new DyFM_Error({
@@ -437,7 +443,14 @@ export abstract class DyNTS_Bot_Main_ControlService<
         })
       }
 
-      return await this.provider.sendMessageToChannelByName(channelName, message);
+      const sentMessage = await this.provider.sendMessageToChannelByName(channelName, message);
+      
+      return {
+        message: sentMessage,
+        providerId: this.provider.getProviderId(),
+        providerType: this.provider.getProviderName() as any,
+        provider: this.provider
+      };
     } catch (error) {
       DyFM_Error.logSimple('Error sending message to channel by name:', error);
 
@@ -446,21 +459,21 @@ export abstract class DyNTS_Bot_Main_ControlService<
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-SMCN0`,
       })
     }
-  }
+  } */
 
-  async clearChannel(
-    channel: T_MessagingPlatformChannel,
+  /* async clearChannel<T_MessagingPlatformChannel>(
+    channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>,
     issuer: string,
   ): Promise<void> {
     try {
-      DyFM_Log.testInfo('Clearing channel... ', channel.name);
+      DyFM_Log.testInfo('Clearing channel... ', channelWrapper.name);
 
-      await this.provider.clearChannel(channel.id);
+      await channelWrapper.provider.clearChannel(channelWrapper);
 
       DyFM_Log.success('Channel cleared');
 
-      this.sendMessageToChannelByName(
-        channel.name,
+      await this.sendMessageToChannelByName(
+        channelWrapper.name,
         '[SYSTEM|OPERATION|RESULT] Channel messages deletion completed successfully.',
         issuer
       );
@@ -472,5 +485,5 @@ export abstract class DyNTS_Bot_Main_ControlService<
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-CC0`,
       })
     }
-  }
+  } */
 }