@futdevpro/nts-dynamo 1.14.13 → 1.14.14

package/src/_modules/bot/_modules/dynamo-bot/_models/dyb-platform.types.ts

@@ -0,0 +1,15 @@
+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 { DyFM_Msg_Message, DyFM_Msg_Conversation, DyFM_Msg_Participant } from '@futdevpro/fsm-dynamo/messaging';
+
+// Dynamo Bot Platform-Specific Types
+// Uses messaging system models as the underlying platform
+export type DyNTS_DyB_Message = DyNTS_Bot_Message<DyFM_Msg_Message>;
+
+// Extended channel interface for dynamo bot with participants
+export interface DyNTS_DyB_Channel extends DyNTS_Bot_Channel<DyFM_Msg_Conversation> {
+  participants?: DyFM_Msg_Participant[];
+}
+
+export type DyNTS_DyB_User = DyNTS_Bot_User<any>; // Messaging system user (generic)

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/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,

package/.eslintrc.json

@@ -1,186 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "es2021": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": "latest"
-  },
-  "plugins": [
-    "@typescript-eslint",
-    "unused-imports",
-    "max-params-no-constructor"
-  ],
-  "rules": {
-    /**
-      WARNING!
-      If the rules have any json parse error, it wont work!
-      (even if have unknown property anywhere)
-    */
-    "no-warning-comments": [
-      "warn",
-      {
-        "terms": [ "todo", "fixme", "removable", "??" ],
-        "location": "anywhere"
-      }
-    ],
-    "indent": [
-      "warn",
-      2,
-      { "SwitchCase": 1 }
-    ],
-    "max-len": [
-      "warn",
-      {
-        "code": 100,
-        "comments": 120
-      }
-    ],
-    "max-lines" : [
-      "warn",
-      1500
-    ],
-    "linebreak-style": "off",
-    "semi": [ "warn", "always" ],
-    "no-unused-vars": "off",
-    "no-prototype-builtins": "off",
-    "no-empty": "warn",
-    "comma-dangle": [
-      "warn", 
-      {
-        "arrays": "always-multiline",
-        "objects": "always-multiline",
-        "imports": "never",
-        "exports": "never",
-        "functions": "only-multiline"
-      }
-    ],
-    "brace-style": [
-      "warn",
-      "1tbs",
-      {
-        "allowSingleLine": true
-      }
-    ],
-    "padding-line-between-statements": [
-      "warn",
-      {
-        /** BREAK BEFORE */
-        "blankLine": "always",
-        "prev": "*",
-        "next": [
-          "return",
-          "throw",
-          "if",
-          "for",
-          "while",
-          "switch",
-          /* "case", */
-          "default"
-        ]
-      },
-      {
-        /** BREAK AFTER */
-        "blankLine": "always",
-        "prev": [
-          "const",
-          "let",
-          "var",
-          "break"
-        ],
-        "next": "*"
-      },
-      { /** CAN FOLLOW (this must be after the BREAK AFTER and BREAK BEFORE) */
-        "blankLine": "any",
-        "prev": [
-          "const",
-          "let",
-          "var"
-        ],
-        "next": [
-          "const",
-          "let",
-          "var"
-        ]
-      }
-    ],
-    "prefer-const": "warn",
-    "no-case-declarations": "warn",
-    "no-fallthrough": "off",
-    "keyword-spacing": "warn",
-    "no-else-return": "off",
-    "no-restricted-imports": [
-      "error",
-      {
-        "paths": [
-          {
-            "name": "../../../../../*",
-            "message": "Dont use long paths, create and use bridge/share index files instead, but better to avoid any of them, so try to resolve other way"
-          }
-        ]
-      }
-    ],
-    "max-lines-per-function": [
-      "warn",
-      {
-        "max": 150,
-        "skipComments": true,
-        "skipBlankLines": true
-      }
-    ],
-    "id-length": [
-      "warn",
-      {
-        "min": 3,
-        "max": 40,
-        "exceptions": [
-          "i", "j", "a", "b", "x", "y",
-          "id", "to", "en", "hu", "ok",
-          "no", "or", "my", "ee"
-        ]
-      }
-    ],
-    "no-duplicate-imports": "warn",
-    "max-params": [
-      "warn",
-      {
-        "max": 4
-      }
-    ],
-    "max-params-no-constructor/max-params-no-constructor": [
-      "warn", 5
-    ],
-    "quotes": [
-      "warn",
-      "single",
-      { "allowTemplateLiterals": true }
-    ],
-    "object-curly-spacing": [ "warn", "always" ],
-    "array-bracket-spacing": [
-      "warn",
-      "always",
-      { "objectsInArrays": false, "arraysInArrays": false }
-    ],
-    "@typescript-eslint/quotes": [
-      "warn",
-      "single",
-      { "allowTemplateLiterals": true }
-    ],
-    "@typescript-eslint/no-unused-vars": "warn",
-    "@typescript-eslint/explicit-function-return-type": [
-      "warn",
-      {
-        "allowTypedFunctionExpressions": false
-      }
-    ],
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/typedef": "warn",
-    "@typescript-eslint/no-unsafe-function-type": "warn",
-    "@typescript-eslint/ban-types": "off"
-  }
-}