@futdevpro/nts-dynamo 1.14.29 → 1.14.32

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

@@ -1,403 +0,0 @@
-import { DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../../../_models/bot-messaging-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_MessagingProvider_Type } from '../../../_enums/bot-message-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_MessagingProvider implements DyNTS_Bot_MessagingProvider<
-  DyNTS_DyB_Channel,
-  DyNTS_DyB_Message,
-  DyNTS_DyB_User
-> {
-  private isInitialized: boolean = false;
-  private config: DyNTS_Bot_MessagingProvider_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_MessagingProvider_Config): Promise<void> {
-    this.config = config;
-    
-    if (config.messageProvider !== DyNTS_Bot_MessagingProvider_Type.dynamo) {
-      throw new Error(`Invalid provider type: ${config.messageProvider}. 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';
-  }
-
-  getProviderId(): string {
-    return this.config.providerId || this.getProviderName();
-  }
-
-  isReady(): boolean {
-    return this.isInitialized;
-  }
-
-  // Helper method to get config
-  getConfig(): DyNTS_Bot_MessagingProvider_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/slack-bot/_collections/slb-operations.util.ts

@@ -1,18 +0,0 @@
-import { DyNTS_Bot_Operations_Util } from '../../../_collections/bot-operations.util';
-import { DyNTS_SlB_Message, DyNTS_SlB_Channel, DyNTS_SlB_User } from '../_models/slb-platform.types';
-import { DyNTS_SlB_MessagingProvider } from '../_services/slb-messaging-provider.service';
-
-/**
- * Slack Bot Operations Utility
- * 
- * Platform-specific implementation of bot operations for Slack
- */
-export class DyNTS_SlB_Operations_Util extends DyNTS_Bot_Operations_Util<
-  DyNTS_SlB_Channel,
-  DyNTS_SlB_Message,
-  DyNTS_SlB_User,
-  DyNTS_SlB_MessagingProvider
-> {
-  // Slack-specific operations can be added here
-  // All base operations are inherited from the generic class
-}

package/src/_modules/bot/_modules/slack-bot/_services/slb-messaging-provider.service.ts

@@ -1,156 +0,0 @@
-import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../../../_models/bot-messaging-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_MessagingProvider_Type } from '../../../_enums/bot-message-provider.enum';
-import { DyNTS_SlB_Message, DyNTS_SlB_Channel, DyNTS_SlB_User } from '../_models/slb-platform.types';
-
-export class DyNTS_SlB_MessagingProvider implements DyNTS_Bot_MessagingProvider<
-  DyNTS_SlB_Channel,
-  DyNTS_SlB_Message,
-  DyNTS_SlB_User
-> {
-  private isInitialized: boolean = false;
-  private config: DyNTS_Bot_MessagingProvider_Config;
-  
-  // Event handlers
-  private messageHandlers: Array<(message: DyNTS_SlB_Message, issuer: string) => void> = [];
-  private readyHandlers: Array<() => void> = [];
-  private errorHandlers: Array<(error: Error) => void> = [];
-
-  async initialize(config: DyNTS_Bot_MessagingProvider_Config): Promise<void> {
-    this.config = config;
-    
-    if (config.messageProvider !== DyNTS_Bot_MessagingProvider_Type.slack) {
-      throw new Error(`Invalid provider type: ${config.messageProvider}. Expected 'slack'`);
-    }
-
-    if (!config.slack) {
-      throw new Error('Slack configuration is required');
-    }
-
-    this.isInitialized = true;
-    // TODO: Initialize Slack client
-  }
-
-  async login(token: string): Promise<void> {
-    if (!this.isInitialized) {
-      throw new Error('Provider not initialized. Call initialize() first.');
-    }
-    // TODO: Implement Slack login
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  // Channel operations
-  async getChannelByName(name: string): Promise<DyNTS_SlB_Channel> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_SlB_Message[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async clearChannel(channelId: string): Promise<void> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  // Message operations
-  async sendMessage(channelId: string, content: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async replyToMessage(messageId: string, channelId: string, content: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async sendTyping(channelId: string): Promise<void> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async fetchMessages(channelId: string, limit: number): Promise<DyNTS_SlB_Message[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async fetchAllMessagesWithPaging(channelId: string, maxFetch?: number): Promise<DyNTS_SlB_Message[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async deleteMessage(messageId: string, channelId: string): Promise<void> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  // User operations
-  async getUserByName(username: string): Promise<DyNTS_SlB_User> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  getUserMention(userId: string): string {
-    return `<@${userId}>`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_SlB_User[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  // Advanced message queries
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_SlB_Message> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_SlB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
-    throw new Error('Slack provider not yet implemented');
-  }
-
-  // Event binding
-  onMessage(handler: (message: DyNTS_SlB_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 'slack-bot-stub';
-  }
-
-  getBotDisplayName(): string {
-    return 'Slack Bot (Stub)';
-  }
-
-  getProviderName(): string {
-    return 'slack';
-  }
-
-  getProviderId(): string {
-    return this.config?.providerId || this.getProviderName();
-  }
-
-  isReady(): boolean {
-    return this.isInitialized;
-  }
-}

package/src/_modules/bot/_modules/teams-bot/_collections/teb-operations.util.ts

@@ -1,18 +0,0 @@
-import { DyNTS_Bot_Operations_Util } from '../../../_collections/bot-operations.util';
-import { DyNTS_TeB_Message, DyNTS_TeB_Channel, DyNTS_TeB_User } from '../_models/teb-platform.types';
-import { DyNTS_TeB_MessagingProvider } from '../_services/teb-messaging-provider.service';
-
-/**
- * Teams Bot Operations Utility
- * 
- * Platform-specific implementation of bot operations for Teams
- */
-export class DyNTS_TeB_Operations_Util extends DyNTS_Bot_Operations_Util<
-  DyNTS_TeB_Channel,
-  DyNTS_TeB_Message,
-  DyNTS_TeB_User,
-  DyNTS_TeB_MessagingProvider
-> {
-  // Teams-specific operations can be added here
-  // All base operations are inherited from the generic class
-}