@futdevpro/nts-dynamo 1.14.13 → 1.14.15

package/src/_modules/bot/_modules/dynamo-bot/_services/dyb-provider.service.ts

@@ -0,0 +1,399 @@
+import { DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../../../_models/bot-provider.interface';
+import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
+import { DyNTS_Bot_Provider_Type } from '../../../_enums/bot-provider.enum';
+import { DyNTS_DyB_Message, DyNTS_DyB_Channel, DyNTS_DyB_User } from '../_models/dyb-platform.types';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+import { DyNTS_Msg_Main_ControlService } from '../../../../messaging/_services/msg-main.control-service';
+import { DyNTS_Msg_Message_DataService } from '../../../../messaging/_services/msg-message.data-service';
+import { DyNTS_Msg_Conversation_DataService } from '../../../../messaging/_services/msg-conversation.data-service';
+import { DyNTS_Msg_Events_Service } from '../../../../messaging/_services/msg-events.service';
+import { DyFM_Msg_Conversation, DyFM_Msg_EventKey, DyFM_Msg_Message, DyFM_Msg_Participant } from '@futdevpro/fsm-dynamo/messaging';
+
+export class DyNTS_DyB_Provider implements DyNTS_Bot_Provider<
+  DyNTS_DyB_Channel,
+  DyNTS_DyB_Message,
+  DyNTS_DyB_User
+> {
+  private isInitialized: boolean = false;
+  private config: DyNTS_Bot_Provider_Config;
+  private conversationCache: Map<string, DyNTS_DyB_Channel>;
+  private userCache: Map<string, DyNTS_DyB_User>;
+  
+  // Event handlers
+  private messageHandlers: Array<(message: DyNTS_DyB_Message, issuer: string) => void> = [];
+  private readyHandlers: Array<() => void> = [];
+  private errorHandlers: Array<(error: Error) => void> = [];
+
+  // Services
+  private messagingService: DyNTS_Msg_Main_ControlService;
+  private eventsService: DyNTS_Msg_Events_Service;
+
+  constructor() {
+    this.conversationCache = new Map();
+    this.userCache = new Map();
+    this.messagingService = DyNTS_Msg_Main_ControlService.getInstance();
+    this.eventsService = DyNTS_Msg_Events_Service.getInstance();
+  }
+
+  async initialize(config: DyNTS_Bot_Provider_Config): Promise<void> {
+    this.config = config;
+    
+    if (config.provider !== DyNTS_Bot_Provider_Type.dynamo) {
+      throw new Error(`Invalid provider type: ${config.provider}. Expected 'dynamo'`);
+    }
+
+    this.isInitialized = true;
+    DyFM_Log.success('Dynamo bot provider initialized');
+  }
+
+  async login(token?: string): Promise<void> {
+    if (!this.isInitialized) {
+      throw new Error('Provider not initialized. Call initialize() first.');
+    }
+
+    // Setup event listeners for messaging events
+    this.setupEventListeners();
+
+    // Trigger ready handlers
+    this.readyHandlers.forEach(handler => handler());
+    
+    DyFM_Log.success('Dynamo bot provider logged in');
+  }
+
+  private setupEventListeners(): void {
+    // Listen to messaging events and convert them to bot events
+    // Note: This would require extending the events service to support custom listeners
+    // For now, we'll implement a basic approach
+    DyFM_Log.info('Dynamo bot event listeners setup (messaging integration)');
+  }
+
+  // Channel operations
+  async getChannelByName(name: string): Promise<DyNTS_DyB_Channel> {
+    if (this.conversationCache.has(name)) {
+      return this.conversationCache.get(name);
+    }
+
+    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    // Try to find conversation by name or platformChannelId
+    const conversation: DyFM_Msg_Conversation = await conversationService.dataDBService.findOne({
+      $or: [
+        { name: name },
+        { platformChannelId: name }
+      ],
+      __deleted: { $exists: false }
+    });
+
+    if (!conversation) {
+      throw new Error(`No conversation found with name "${name}"`);
+    }
+
+    const channel: DyNTS_DyB_Channel = this.translateChannel(conversation);
+    this.conversationCache.set(name, channel);
+    return channel;
+  }
+
+  async getChannelById(conversationId: string): Promise<DyNTS_DyB_Channel> {
+    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    const conversation: DyFM_Msg_Conversation = await conversationService.getDataById(conversationId);
+    if (!conversation) {
+      throw new Error(`No conversation found with ID "${conversationId}"`);
+    }
+
+    return this.translateChannel(conversation);
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DyB_Message> {
+    const channel: DyNTS_DyB_Channel = await this.getChannelByName(channelName);
+    return this.sendMessage(channel.id, message);
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_DyB_Message[]> {
+    const channel: DyNTS_DyB_Channel = await this.getChannelByName(channelName);
+    return this.fetchMessages(channel.id, limit);
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_DyB_Message> {
+    const messages: DyNTS_DyB_Message[] = await this.getMessagesFromChannelByChannelName(channelName, 1);
+    return messages.length > 0 ? messages[0] : null;
+  }
+
+  async clearChannel(channelId: string): Promise<void> {
+    // For messaging system, we don't actually delete messages
+    // This could be implemented to mark messages as deleted or archived
+    DyFM_Log.warn('Clear channel not implemented for messaging system');
+  }
+
+  // Message operations
+  async sendMessage(channelId: string, content: string): Promise<DyNTS_DyB_Message> {
+    const botUserId: string = this.config.dynamo?.botUserId || 'dynamo-bot';
+    
+    const message: DyFM_Msg_Message = await this.messagingService.sendMessage(
+      channelId,
+      {
+        content,
+        type: 'text' as any,
+      },
+      botUserId,
+      'dynamo-bot'
+    );
+
+    return this.translateMessage(message);
+  }
+
+  async replyToMessage(messageId: string, channelId: string, content: string): Promise<DyNTS_DyB_Message> {
+    // In messaging system, we can't directly reply to a message
+    // Instead, we'll send a new message with reference to the original
+    const replyContent: string = `[Reply to message ${messageId}] ${content}`;
+    return this.sendMessage(channelId, replyContent);
+  }
+
+  async sendTyping(channelId: string): Promise<void> {
+    // Typing indicators not implemented for messaging system
+    DyFM_Log.info('Typing indicator not supported in messaging system');
+  }
+
+  async fetchMessages(channelId: string, limit: number): Promise<DyNTS_DyB_Message[]> {
+    const messageService: DyNTS_Msg_Message_DataService = new DyNTS_Msg_Message_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    const messages: DyFM_Msg_Message[] = await messageService.dataDBService.find({
+      conversationId: channelId,
+      __deleted: { $exists: false },
+      $sort: { sentAt: -1 },
+      $limit: limit
+    });
+
+    return messages.map((msg: DyFM_Msg_Message) => this.translateMessage(msg));
+  }
+
+  async fetchAllMessagesWithPaging(channelId: string, maxFetch: number = 1000): Promise<DyNTS_DyB_Message[]> {
+    return this.fetchMessages(channelId, maxFetch);
+  }
+
+  async deleteMessage(messageId: string, channelId: string): Promise<void> {
+    await this.messagingService.deleteMessage(messageId, 'dynamo-bot', 'dynamo-bot');
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_DyB_User> {
+    if (this.userCache.has(username)) {
+      return this.userCache.get(username);
+    }
+
+    // In messaging system, we don't have a direct user lookup by name
+    // This would need to be implemented based on your user management system
+    const user: DyNTS_DyB_User = {
+      id: username,
+      username: username,
+      displayName: username,
+      isBot: false,
+      rawPlatformUser: null
+    };
+
+    this.userCache.set(username, user);
+    return user;
+  }
+
+  getUserMention(userId: string): string {
+    return `@${userId}`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_DyB_User[]> {
+    const channel: DyNTS_DyB_Channel = await this.getChannelByName(channelName);
+    const participants: DyFM_Msg_Participant[] = channel.rawPlatformChannel.participants;
+    
+    return participants.map(participant => this.translateUser(participant));
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    const members: DyNTS_DyB_User[] = await this.readMembersInChannel(channelName);
+    return members.map(member => member.username);
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_DyB_Message> {
+    const messages: DyNTS_DyB_Message[] = await this.fetchAllMessagesWithPaging(
+      (await this.getChannelByName(channelName)).id,
+      1000
+    );
+    
+    return messages.find(msg => msg.authorName === username) || null;
+  }
+
+  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_DyB_Message> {
+    const messages: DyNTS_DyB_Message[] = await this.fetchAllMessagesWithPaging(
+      (await this.getChannelByName(channelName)).id,
+      1000
+    );
+    
+    return messages.find(msg => 
+      msg.content.includes(`@${username}`) || 
+      msg.content.includes(username)
+    ) || null;
+  }
+
+  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
+    const channel: DyNTS_DyB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DyB_Message[] = await this.fetchAllMessagesWithPaging(channel.id, 1000);
+    
+    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
+    memberNames.forEach((name: string) => {
+      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
+    });
+
+    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
+
+    messages.forEach((message: DyNTS_DyB_Message) => {
+      if (message.timestamp < cutoffTime) return;
+
+      const author = message.authorName;
+      if (memberStatus[author] !== undefined) {
+        memberStatus[author].allMessages++;
+        if (!memberStatus[author].lastMessageDate) {
+          memberStatus[author].lastMessageDate = new Date(message.timestamp);
+        }
+      }
+    });
+
+    return memberNames.map((memberName: string) => {
+      const status: { lastMessageDate: Date | null, allMessages: number } = memberStatus[memberName];
+      return {
+        memberName: memberName,
+        allMessages: status.allMessages,
+        lastMessageDate: status.lastMessageDate
+      };
+    });
+  }
+
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_DyB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    const channel: DyNTS_DyB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DyB_Message[] = await this.fetchAllMessagesWithPaging(channel.id, 1000);
+    
+    const memberStatus: Record<string, { lastMentionDate: Date | null; allMentions: number }> = {};
+    users.forEach((user: DyNTS_DyB_User) => {
+      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
+    });
+
+    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
+
+    messages.forEach((message: DyNTS_DyB_Message) => {
+      if (message.timestamp < cutoffTime) return;
+
+      users.forEach((user: DyNTS_DyB_User) => {
+        if (
+          message.content.includes(`@${user.id}`) && 
+          !memberStatus[user.username].lastMentionDate
+        ) {
+          memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
+          memberStatus[user.username].allMentions++;
+        }
+      });
+    });
+
+    return users.map((user: DyNTS_DyB_User) => {
+      const status: { lastMentionDate: Date | null; allMentions: number } = memberStatus[user.username];
+      return {
+        memberId: user.id,
+        memberName: user.username,
+        allMentions: status.allMentions,
+        lastMentionDate: status.lastMentionDate
+      };
+    });
+  }
+
+  // Platform-specific features (not applicable for messaging system)
+  getRoleByName?(roleName: string): any {
+    return null; // Not applicable for messaging system
+  }
+
+  getRolePingByName?(roleName: string): Promise<string> {
+    return Promise.resolve(''); // Not applicable for messaging system
+  }
+
+  getRolePingsByName?(roleNames: string[]): Promise<string> {
+    return Promise.resolve(''); // Not applicable for messaging system
+  }
+
+  // Event binding
+  onMessage(handler: (message: DyNTS_DyB_Message, issuer: string) => void): void {
+    this.messageHandlers.push(handler);
+  }
+
+  onReady(handler: () => void): void {
+    this.readyHandlers.push(handler);
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandlers.push(handler);
+  }
+
+  // Metadata
+  getBotId(): string {
+    return this.config.dynamo?.botUserId || 'dynamo-bot';
+  }
+
+  getBotDisplayName(): string {
+    return this.config.dynamo?.botDisplayName || 'Dynamo Bot';
+  }
+
+  getProviderName(): string {
+    return 'dynamo';
+  }
+
+  isReady(): boolean {
+    return this.isInitialized;
+  }
+
+  // Helper method to get config
+  getConfig(): DyNTS_Bot_Provider_Config {
+    return this.config;
+  }
+
+  // Translation methods
+  private translateMessage(msgMessage: any): DyNTS_DyB_Message {
+    return {
+      id: msgMessage._id || msgMessage.id,
+      content: msgMessage.content || '',
+      authorId: msgMessage.senderId || msgMessage.authorId,
+      authorName: msgMessage.senderName || msgMessage.authorName,
+      authorDisplayName: msgMessage.senderDisplayName || msgMessage.authorDisplayName,
+      channelId: msgMessage.conversationId || msgMessage.channelId,
+      channelName: msgMessage.conversationName || msgMessage.channelName || 'unknown',
+      timestamp: msgMessage.sentAt ? new Date(msgMessage.sentAt).getTime() : Date.now(),
+      isBot: msgMessage.isAIGenerated || false,
+      replyToMessageId: msgMessage.replyToMessageId,
+      mentions: msgMessage.mentions || [],
+      rawPlatformMessage: msgMessage
+    };
+  }
+
+  private translateChannel(conversation: any): DyNTS_DyB_Channel {
+    return {
+      id: conversation._id || conversation.id,
+      name: conversation.name || conversation.platformChannelId || 'unknown',
+      isTextBased: true,
+      isDM: conversation.type === 'direct',
+      participants: conversation.participants || [],
+      rawPlatformChannel: conversation
+    };
+  }
+
+  private translateUser(user: any): DyNTS_DyB_User {
+    return {
+      id: user.userId || user.id,
+      username: user.username || user.userId || user.id,
+      displayName: user.displayName || user.username || user.userId,
+      isBot: user.isBot || false,
+      rawPlatformUser: user
+    };
+  }
+}

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

@@ -0,0 +1,16 @@
+//
+// Dynamo Bot Provider
+//
+// This module provides messaging system-specific implementation of the Bot provider interface
+// Uses the messaging system as the underlying platform instead of external services
+//
+
+// TYPES
+export * from './_models/dyb-platform.types';
+
+// SERVICES
+export * from './_services/dyb-provider.service';
+
+// COLLECTIONS
+export * from './_collections/dyb-operations.util';
+export * from './_collections/dyb.util';

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

@@ -3,6 +3,7 @@ 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';
+import { DyNTS_DyB_Provider } from '../_modules/dynamo-bot/_services/dyb-provider.service';
 
 export class DyNTS_Bot_Provider_Factory {
 
@@ -17,6 +18,9 @@ export class DyNTS_Bot_Provider_Factory {
       case DyNTS_Bot_Provider_Type.teams:
         return new DyNTS_TeB_Provider();
 
+      case DyNTS_Bot_Provider_Type.dynamo:
+        return new DyNTS_DyB_Provider();
+
       case DyNTS_Bot_Provider_Type.custom:
         if (!config.providerInstance) {
           throw new Error('Custom provider instance is required when provider type is "custom"');

package/src/_modules/bot/index.ts

@@ -34,3 +34,4 @@ export * from './_services/bot-provider-factory.service';
 export * from './_modules/discord-bot';
 export * from './_modules/slack-bot';
 export * from './_modules/teams-bot';
+export * from './_modules/dynamo-bot';

package/src/_modules/discord-assistant/_services/dias.service-base.ts

@@ -10,7 +10,6 @@ import { DyNTS_OAI_GPT_Message_Role } from '../../ai/_modules/open-ai/_enums/oai
 import { DyNTS_DiAs_Util } from '../_collections/dias.util';
 import { DyNTS_DiAs_IO_ControlService } from './dias-io.control-service';
 
-
 export abstract class DyNTS_DiAs_ServiceBase extends DyNTS_DiBo_Main_ControlService {
 
   getLLMChatControlService(): DyNTS_OAI_LLMChat_ServiceBase {

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

@@ -11,13 +11,13 @@ import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings
 
 export abstract class DyNTS_DiBo_Commands_ControlService extends DyNTS_SingletonService {
 
-  static getInstance(): DyNTS_DiBo_Commands_ControlService {
+  /* static getInstance(): DyNTS_DiBo_Commands_ControlService {
     return DyNTS_DiBo_Commands_ControlService.getSingletonInstance();
-  }
+  } */
 
   protected abstract getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService;
-  protected readonly diAs_CS: DyNTS_DiBo_Main_ControlService = 
-    this.getMainDiscordBotControlService();
+  protected diAs_CS: DyNTS_DiBo_Main_ControlService;
+  /* protected abstract readonly diAs_CS: DyNTS_DiBo_Main_ControlService; */
 
   get discordServer(): Guild {
     return this.diAs_CS?.discordServer;
@@ -41,6 +41,24 @@ export abstract class DyNTS_DiBo_Commands_ControlService extends DyNTS_Singleton
     }
   }
 
+  async setup(issuer: string): Promise<void> {
+    try {
+      this.diAs_CS = this.getMainDiscordBotControlService();
+
+      if (!this.diAs_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Main Discord Bot Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-S01`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-S00`,
+      })
+    }
+  }
+
   async handleCommand(message: Message, issuer: string): Promise<void> {
     try {
       let haveCommandOperator = false;
@@ -111,7 +129,6 @@ export abstract class DyNTS_DiBo_Commands_ControlService extends DyNTS_Singleton
       })
     }
   }
-
 }
 
 

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

@@ -18,6 +18,7 @@ export abstract class DyNTS_DiBo_IO_ControlService extends DyNTS_SingletonServic
 
   protected abstract getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService;
   protected abstract mainDiscordBot_CS: DyNTS_DiBo_Main_ControlService;
+  /* protected abstract readonly mainDiscordBot_CS: DyNTS_DiBo_Main_ControlService; */
 
   get discordServer(): Guild {
     return this.mainDiscordBot_CS?.discordServer;
@@ -38,34 +39,32 @@ export abstract class DyNTS_DiBo_IO_ControlService extends DyNTS_SingletonServic
     super();
   }   */
 
-  async start(issuer: string): Promise<void> {
+  async setup(issuer: string): Promise<void> {
     try {
       this.mainDiscordBot_CS = this.getMainDiscordBotControlService();
       this.commands_CS = this.getCommandsControlService();
 
-      if (!this.discordServer) {
+      if (!this.mainDiscordBot_CS) {
         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`,
+          ...this.getDefaultErrorSettings('setup', new Error('Main Discord Bot Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-IO-S01`,
+        })
+      }
+
+      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-DiBo-IO-S02`,
         })
       }
     } catch (error) {
       throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('start', error, issuer),
+        ...this.getDefaultErrorSettings('setup', error, issuer),
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-IO-S000`,
       })
     }
   }
 
-  /* async  */
-
   async handleNewMessage(message: Message, issuer: string): Promise<void> {
     try {
       if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
@@ -118,7 +117,7 @@ export abstract class DyNTS_DiBo_IO_ControlService extends DyNTS_SingletonServic
           new Error('Bot not initialized yet').stack
         )
 
-        await this.start(issuer);
+        //await this.mainDiscordBot_CS.start(issuer);
 
         if (!this.discordServer || !this.mainDiscordBot_CS || !this.botClientId) {
           DyFM_Log.H_error(

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

@@ -8,6 +8,7 @@ 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';
+import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
 
 
 /**
@@ -70,6 +71,9 @@ export abstract class DyNTS_DiBo_Main_ControlService extends DyNTS_SingletonServ
   protected routines_CS: DyNTS_DiBo_Routines_ControlService;
   protected abstract getRoutinesControlService(): DyNTS_DiBo_Routines_ControlService;
 
+  protected commands_CS: DyNTS_DiBo_Commands_ControlService;
+  protected abstract getCommandsControlService(): DyNTS_DiBo_Commands_ControlService;
+
   private _channelsByNames: {
     [key: string]: TextChannel;
   } = {};
@@ -163,6 +167,14 @@ export abstract class DyNTS_DiBo_Main_ControlService extends DyNTS_SingletonServ
           DyNTS_DiBo_global_settings.channelSettings.reportChannelName
         );
       }
+      
+      this.botIO_CS = this.getBotIOControlService();
+      this.routines_CS = this.getRoutinesControlService();
+      this.commands_CS = this.getCommandsControlService();
+
+      await this.botIO_CS.setup(issuer);
+      await this.routines_CS.setup(issuer);
+      await this.commands_CS.setup(issuer);
 
       return new Promise((resolve, reject) => {
         this.client.on('error', (error) => {
@@ -268,11 +280,7 @@ export abstract class DyNTS_DiBo_Main_ControlService extends DyNTS_SingletonServ
 
   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('Discord Bot started')
     } catch (error) {

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

@@ -45,6 +45,16 @@ export abstract class DyNTS_DiBo_Routines_ControlService extends DyNTS_Singleton
     }
   }
 
+  async setup(issuer: string): Promise<void> {
+    try {
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-RCS-S000`,
+      })
+    }
+  }
+
   async start(issuer: string): Promise<void> {
     try {
       await this.startRoutines(issuer);

package/src/_modules/messaging/_services/msg.controller.ts

@@ -48,7 +48,7 @@ export class DyNTS_Msg_Controller extends DyNTS_Controller {
         endpoint: DyFM_msgModule_settings.endPoints.getConversations,
         tasks: [
           async (req: Request, res: Response, issuer: string): Promise<void> => {
-                const userId = this.authService.getIssuerFromRequest(req);
+            const userId = this.authService.getIssuerFromRequest(req);
             
             const conversationService = new DyNTS_Msg_Conversation_DataService({
               issuer,