@futdevpro/nts-dynamo 1.14.8 → 1.14.9

package/src/_modules/bot/_models/bot-user.interface.ts

@@ -0,0 +1,7 @@
+export interface DyNTS_Bot_User<T_PlatformUser = any> {
+  id: string;
+  username: string;
+  displayName: string;
+  isBot: boolean;
+  rawPlatformUser: T_PlatformUser;
+}

package/src/_modules/bot/_modules/discord-bot/_collections/dib-operations.util.ts

@@ -0,0 +1,18 @@
+import { DyNTS_Bot_Operations_Util } from '../../../_collections/bot-operations.util';
+import { DyNTS_DiB_Message, DyNTS_DiB_Channel, DyNTS_DiB_User } from '../_models/dib-platform.types';
+import { DyNTS_DiB_Provider } from '../_services/dib-provider.service';
+
+/**
+ * Discord Bot Operations Utility
+ * 
+ * Platform-specific implementation of bot operations for Discord
+ */
+export class DyNTS_DiB_Operations_Util extends DyNTS_Bot_Operations_Util<
+  DyNTS_DiB_Channel,
+  DyNTS_DiB_Message,
+  DyNTS_DiB_User,
+  DyNTS_DiB_Provider
+> {
+  // Discord-specific operations can be added here
+  // All base operations are inherited from the generic class
+}

package/src/_modules/bot/_modules/discord-bot/_collections/dib.util.ts

@@ -0,0 +1,20 @@
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_DiB_Provider } from '../_services/dib-provider.service';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+
+export class DyNTS_DiB_Util {
+
+  static async reportIn(provider: DyNTS_DiB_Provider): Promise<void> {
+    try {
+      const reportMessage = `${provider.getBotDisplayName()} report for duty! ` +
+        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`;
+
+      await provider.sendMessageToChannelByName(
+        DyNTS_global_settings.bot_settings?.channelSettings?.reportChannelName || 'bot-reports', 
+        reportMessage
+      );
+    } catch (error) {
+      DyFM_Error.logSimple('Failed to report in', error);
+    }
+  }
+}

package/src/_modules/bot/_modules/discord-bot/_models/dib-platform.types.ts

@@ -0,0 +1,9 @@
+import { Message, TextChannel, GuildMember } from 'discord.js';
+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';
+
+// Discord Bot Platform-Specific Types
+export type DyNTS_DiB_Message = DyNTS_Bot_Message<Message>;
+export type DyNTS_DiB_Channel = DyNTS_Bot_Channel<TextChannel>;
+export type DyNTS_DiB_User = DyNTS_Bot_User<GuildMember>;

package/src/_modules/bot/_modules/discord-bot/_services/dib-provider.service.ts

@@ -0,0 +1,462 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel } from 'discord.js';
+import { DyFM_Error, DyFM_Log } 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_DiB_Message, DyNTS_DiB_Channel, DyNTS_DiB_User } from '../_models/dib-platform.types';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+
+export class DyNTS_DiB_Provider implements DyNTS_Bot_Provider<
+  DyNTS_DiB_Channel,
+  DyNTS_DiB_Message,
+  DyNTS_DiB_User
+> {
+  private client: Client;
+  private guild: Guild;
+  private channelCache: Map<string, TextChannel>;
+  private roleCache: Map<string, Role>;
+  private isInitialized: boolean = false;
+  private config: DyNTS_Bot_Provider_Config;
+  
+  // Event handlers
+  private messageHandlers: Array<(message: DyNTS_DiB_Message, issuer: string) => void> = [];
+  private readyHandlers: Array<() => void> = [];
+  private errorHandlers: Array<(error: Error) => void> = [];
+
+  constructor() {
+    this.channelCache = new Map();
+    this.roleCache = new Map();
+  }
+
+  async initialize(config: DyNTS_Bot_Provider_Config): Promise<void> {
+    this.config = config;
+    
+    if (config.provider !== DyNTS_Bot_Provider_Type.discord) {
+      throw new Error(`Invalid provider type: ${config.provider}. Expected 'discord'`);
+    }
+
+    if (!config.discord) {
+      throw new Error('Discord configuration is required');
+    }
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMembers,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.GuildVoiceStates,
+      ],
+      partials: [
+        Partials.Channel,
+      ],
+    });
+
+    this.isInitialized = true;
+    DyFM_Log.success('Discord provider initialized');
+  }
+
+  async login(token: string): Promise<void> {
+    if (!this.isInitialized) {
+      throw new Error('Provider not initialized. Call initialize() first.');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.client.on('ready', async () => {
+        if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+          DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
+        }
+
+        // Get guild
+        this.guild = this.client.guilds.cache.get(this.config.discord.guildId);
+        if (!this.guild) {
+          reject(new Error(`Discord server not found with ID: ${this.config.discord.guildId}`));
+          return;
+        }
+
+        // Set up event listeners
+        this.setupEventListeners();
+
+        // Trigger ready handlers
+        this.readyHandlers.forEach(handler => handler());
+
+        resolve();
+      });
+
+      this.client.on('error', (error) => {
+        this.errorHandlers.forEach(handler => handler(error));
+        reject(error);
+      });
+
+      this.client.login(token).catch(reject);
+    });
+  }
+
+  private setupEventListeners(): void {
+    this.client.on('messageCreate', (message: Message) => {
+      if (message.author.bot) return; // Ignore bot messages
+      
+      const botMessage = this.translateMessage(message);
+      this.messageHandlers.forEach(handler => handler(botMessage, 'discord-message'));
+    });
+  }
+
+  // Channel operations
+  async getChannelByName(name: string): Promise<DyNTS_DiB_Channel> {
+    if (this.channelCache.has(name)) {
+      return this.translateChannel(this.channelCache.get(name));
+    }
+
+    const channel = this.guild.channels.cache.find(
+      (ch) => ch.name === name && ch.isTextBased()
+    ) as TextChannel;
+
+    if (!channel) {
+      throw new Error(`No text channel found with name "${name}"`);
+    }
+
+    this.channelCache.set(name, channel);
+    return this.translateChannel(channel);
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DiB_Message> {
+    const channel = await this.getChannelByName(channelName);
+    const discordChannel = this.channelCache.get(channelName);
+    const sentMessage = await discordChannel.send(message);
+    return this.translateMessage(sentMessage);
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_DiB_Message[]> {
+    const channel = await this.getChannelByName(channelName);
+    const discordChannel = this.channelCache.get(channelName);
+    const messages = await discordChannel.messages.fetch({ limit });
+    return Array.from(messages.values()).map(msg => this.translateMessage(msg));
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_DiB_Message> {
+    const channel = await this.getChannelByName(channelName);
+    const discordChannel = this.channelCache.get(channelName);
+    const messages = await discordChannel.messages.fetch({ limit: 1 });
+    const lastMessage = messages.first();
+    return lastMessage ? this.translateMessage(lastMessage) : null;
+  }
+
+  async clearChannel(channelId: string): Promise<void> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+
+    let lastId: string | undefined = undefined;
+    let fetched = 0;
+    const maxFetch = 1000;
+
+    while (fetched < maxFetch) {
+      const options: { limit: number; before?: string } = { limit: 100 };
+      if (lastId) options.before = lastId;
+
+      const messageCollection: Collection<string, Message> = await channel.messages.fetch(options);
+      if (messageCollection.size === 0) break;
+
+      const deletePromises = Array.from(messageCollection.values()).map(message => 
+        message.delete().catch((error) => {
+          DyFM_Error.logSimple('Failed to delete message', error);
+        })
+      );
+
+      await Promise.all(deletePromises);
+      lastId = Array.from(messageCollection.values()).pop()?.id;
+      fetched += messageCollection.size;
+    }
+  }
+
+  // Message operations
+  async sendMessage(channelId: string, content: string): Promise<DyNTS_DiB_Message> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    const message = await channel.send(content);
+    return this.translateMessage(message);
+  }
+
+  async replyToMessage(messageId: string, channelId: string, content: string): Promise<DyNTS_DiB_Message> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    const message = await channel.messages.fetch(messageId);
+    const reply = await message.reply(content);
+    return this.translateMessage(reply);
+  }
+
+  async sendTyping(channelId: string): Promise<void> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    await channel.sendTyping();
+  }
+
+  async fetchMessages(channelId: string, limit: number): Promise<DyNTS_DiB_Message[]> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    const messages = await channel.messages.fetch({ limit });
+    return Array.from(messages.values()).map(msg => this.translateMessage(msg));
+  }
+
+  async fetchAllMessagesWithPaging(channelId: string, maxFetch: number = 1000): Promise<DyNTS_DiB_Message[]> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+
+    let lastId: string | undefined = undefined;
+    let fetched = 0;
+    const allMessages: DyNTS_DiB_Message[] = [];
+
+    while (fetched < maxFetch) {
+      const options: { limit: number; before?: string } = { limit: 100 };
+      if (lastId) options.before = lastId;
+
+      const messageCollection: Collection<string, Message> = await channel.messages.fetch(options);
+      if (messageCollection.size === 0) break;
+
+      Array.from(messageCollection.values()).forEach((msg: Message) => {
+        allMessages.push(this.translateMessage(msg));
+      });
+
+      lastId = Array.from(messageCollection.values()).pop()?.id;
+      fetched += messageCollection.size;
+    }
+
+    return allMessages;
+  }
+
+  async deleteMessage(messageId: string, channelId: string): Promise<void> {
+    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    const message = await channel.messages.fetch(messageId);
+    await message.delete();
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_DiB_User> {
+    const member = this.guild.members.cache.find(m => m.user.username === username);
+    if (!member) {
+      throw new Error(`User not found with username: ${username}`);
+    }
+    return this.translateUser(member);
+  }
+
+  getUserMention(userId: string): string {
+    return `<@${userId}>`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_DiB_User[]> {
+    const channel = await this.getChannelByName(channelName);
+    const discordChannel = this.channelCache.get(channelName);
+    const members = await this.guild.members.fetch();
+    
+    const allowedMembers = members.filter((member) =>
+      discordChannel.permissionsFor(member)?.has('ViewChannel')
+    );
+
+    return Array.from(allowedMembers.values()).map(member => this.translateUser(member));
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    const members = await this.readMembersInChannel(channelName);
+    return members.map(member => member.username);
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
+    const messages = 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_DiB_Message> {
+    const messages = 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 = await this.getChannelByName(channelName);
+    const messages = await this.fetchAllMessagesWithPaging(channel.id, 1000);
+    
+    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
+    memberNames.forEach(name => {
+      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
+    });
+
+    const cutoffTime = Date.now() - (3 * 7 * 24 * 60 * 60 * 1000); // 3 weeks
+
+    messages.forEach((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) => {
+      const status = memberStatus[memberName];
+      return {
+        memberName: memberName,
+        allMessages: status.allMessages,
+        lastMessageDate: status.lastMessageDate
+      };
+    });
+  }
+
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_DiB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    const channel = await this.getChannelByName(channelName);
+    const messages = await this.fetchAllMessagesWithPaging(channel.id, 1000);
+    
+    const memberStatus: Record<string, { lastMentionDate: Date | null, allMentions: number }> = {};
+    users.forEach(user => {
+      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
+    });
+
+    const cutoffTime = Date.now() - (3 * 7 * 24 * 60 * 60 * 1000); // 3 weeks
+
+    messages.forEach((message) => {
+      if (message.timestamp < cutoffTime) return;
+
+      users.forEach(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) => {
+      const status = memberStatus[user.username];
+      return {
+        memberId: user.id,
+        memberName: user.username,
+        allMentions: status.allMentions,
+        lastMentionDate: status.lastMentionDate
+      };
+    });
+  }
+
+  // Discord-specific features
+  getRoleByName(roleName: string): Role {
+    if (this.roleCache.has(roleName)) {
+      return this.roleCache.get(roleName);
+    }
+
+    const role = this.guild.roles.cache.find(r => r.name === roleName);
+    if (role) {
+      this.roleCache.set(roleName, role);
+    }
+    return role;
+  }
+
+  async getRolePingByName(roleName: string): Promise<string> {
+    const role = this.getRoleByName(roleName);
+    return role ? `<@&${role.id}>` : '';
+  }
+
+  async getRolePingsByName(roleNames: string[]): Promise<string> {
+    const pings: string[] = await Promise.all(
+      roleNames.map(roleName => this.getRolePingByName(roleName))
+    );
+    return pings.join(' ');
+  }
+
+  // Event binding
+  onMessage(handler: (message: DyNTS_DiB_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.client?.user?.id;
+  }
+
+  getBotDisplayName(): string {
+    return this.client?.user?.displayName;
+  }
+
+  getProviderName(): string {
+    return 'discord';
+  }
+
+  isReady(): boolean {
+    return this.isInitialized && this.client?.readyAt !== null;
+  }
+
+  // Translation methods
+  private translateMessage(discordMessage: Message): DyNTS_DiB_Message {
+    return {
+      id: discordMessage.id,
+      content: discordMessage.content,
+      authorId: discordMessage.author.id,
+      authorName: discordMessage.author.username,
+      authorDisplayName: discordMessage.author.displayName,
+      channelId: discordMessage.channelId,
+      channelName: (discordMessage.channel as TextChannel)?.name || 'unknown',
+      timestamp: discordMessage.createdTimestamp,
+      isBot: discordMessage.author.bot,
+      replyToMessageId: discordMessage.reference?.messageId,
+      mentions: Array.from(discordMessage.mentions.users.keys()),
+      rawPlatformMessage: discordMessage
+    };
+  }
+
+  private translateChannel(discordChannel: TextChannel): DyNTS_DiB_Channel {
+    return {
+      id: discordChannel.id,
+      name: discordChannel.name,
+      isTextBased: discordChannel.isTextBased(),
+      isDM: discordChannel.isDMBased(),
+      rawPlatformChannel: discordChannel
+    };
+  }
+
+  private translateUser(discordMember: GuildMember): DyNTS_DiB_User {
+    return {
+      id: discordMember.user.id,
+      username: discordMember.user.username,
+      displayName: discordMember.displayName,
+      isBot: discordMember.user.bot,
+      rawPlatformUser: discordMember
+    };
+  }
+}

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

@@ -0,0 +1,15 @@
+//
+// Discord Bot Provider
+//
+// This module provides Discord-specific implementation of the Bot provider interface
+//
+
+// TYPES
+export * from './_models/dib-platform.types';
+
+// SERVICES
+export * from './_services/dib-provider.service';
+
+// COLLECTIONS
+export * from './_collections/dib-operations.util';
+export * from './_collections/dib.util';

package/src/_modules/bot/_modules/slack-bot/_collections/slb-operations.util.ts

@@ -0,0 +1,18 @@
+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_Provider } from '../_services/slb-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_Provider
+> {
+  // Slack-specific operations can be added here
+  // All base operations are inherited from the generic class
+}

package/src/_modules/bot/_modules/slack-bot/_models/slb-platform.types.ts

@@ -0,0 +1,9 @@
+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';
+
+// Slack Bot Platform-Specific Types
+// TODO: Replace 'any' with actual Slack SDK types when implementing
+export type DyNTS_SlB_Message = DyNTS_Bot_Message<any>;
+export type DyNTS_SlB_Channel = DyNTS_Bot_Channel<any>;
+export type DyNTS_SlB_User = DyNTS_Bot_User<any>;