@futdevpro/nts-dynamo 1.14.8 → 1.14.10

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

@@ -0,0 +1,149 @@
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_Provider } from '../_models/bot-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_LastMessageDate } from '../_models/bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from '../_models/bot-last-mention-date.interface';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+export abstract class DyNTS_Bot_Operations_Util<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  >
+> {
+
+  static async findChannelByName<
+    T_PlatformChannel extends DyNTS_Bot_Channel<any>, 
+    T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, any, any>
+  >(
+    provider: T_PlatformProvider, 
+    name: string
+  ): Promise<T_PlatformChannel> {
+    const channel = await provider.getChannelByName(name);
+
+    if (!channel) {
+      DyFM_Log.error(`No text channel found with name "${name}"`)
+      return null;
+    }
+
+    return channel;
+  }
+
+  static async sendMessageToChannelByName<T_PlatformChannel extends DyNTS_Bot_Channel<any>, T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string, 
+    message: string
+  ): Promise<void> {
+    const channel = await this.findChannelByName(provider, channelName);
+
+    if (channel?.isTextBased) {
+      await provider.sendMessageToChannelByName(channelName, message);
+      DyFM_Log.success('Message sent to channel', channel.name);
+    } else {
+      DyFM_Log.error(`Channel is not text based "${channelName}"`);
+    }
+  }
+
+  static async readMembersInChannel<T_PlatformUser extends DyNTS_Bot_User<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, any, T_PlatformUser>>(
+    provider: T_PlatformProvider, 
+    channelName: string
+  ): Promise<T_PlatformUser[]> {
+    return await provider.readMembersInChannel(channelName);
+  }
+
+  static async readMemberNamesInChannel<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string
+  ): Promise<string[]> {
+    return await provider.readMemberNamesInChannel(channelName);
+  }
+
+  static async fetchAllMessagesWithPaging<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelId: string,
+    maxFetch = 1000
+  ): Promise<T_PlatformMessage[]> {
+    return await provider.fetchAllMessagesWithPaging(channelId, maxFetch);
+  }
+
+  static async readLastMessageDatesByMembers<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string,
+    memberNames: string[]
+  ): Promise<DyNTS_Bot_LastMessageDate[]> {
+    return await provider.readLastMessageDatesByMembers(channelName, memberNames);
+  }
+
+  static async readLastMessageWithMemberNamePingInIt<T_PlatformUser extends DyNTS_Bot_User<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, any, T_PlatformUser>>(
+    provider: T_PlatformProvider,
+    channelName: string,
+    users: T_PlatformUser[]
+  ): Promise<DyNTS_Bot_LastMentionDate[]> {
+    return await provider.readLastMessageWithMemberNamePingInIt(channelName, users);
+  }
+
+  static readMentionsInChannel = this.readLastMessageWithMemberNamePingInIt;
+
+  static async readLastMessagesInChannel<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformChannel extends DyNTS_Bot_Channel<any>, T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelName: string,
+  ): Promise<T_PlatformMessage[]> {
+    const channel = await provider.getChannelByName(channelName);
+    return await provider.fetchMessages(channel.id, 100);
+  }
+  
+  static async getLastMessageInChannel<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelName: string
+  ): Promise<T_PlatformMessage> {
+    return await provider.getLastMessageInChannel(channelName);
+  }
+
+  static async deleteMessage<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    messageId: string, 
+    channelId: string
+  ): Promise<void> {
+    await provider.deleteMessage(messageId, channelId).catch((error) => {
+      DyFM_Error.logSimple('Failed to delete message', error);
+    });
+
+    DyFM_Log.success('Message deleted');
+  }
+
+  static async reportIn<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(provider: T_PlatformProvider): Promise<void> {
+    try {
+      const lastReportMessage = await this.getLastMessageInChannel(
+        provider,
+        'bot-reports' // Use default since we can't access channelSettings from provider config
+      );
+      
+      const reportMessage = `${provider.getBotDisplayName()} report for duty! ` +
+        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`;
+
+      if (lastReportMessage?.content === reportMessage) {
+        await this.deleteMessage(provider, lastReportMessage.id, lastReportMessage.channelId).catch((error) => {
+          DyFM_Error.logSimple('Failed to delete message', error);
+        });
+      }
+
+      this.sendMessageToChannelByName(
+        provider, 
+        'bot-reports', // Use default since we can't access channelSettings from provider config
+        reportMessage
+      );
+    } catch (error) {
+      DyFM_Error.logSimple('Failed to report in', error);
+    }
+  }
+}

package/src/_modules/bot/_enums/bot-provider.enum.ts

@@ -0,0 +1,6 @@
+export enum DyNTS_Bot_Provider_Type {
+  discord = 'discord',
+  slack = 'slack',
+  teams = 'teams',
+  custom = 'custom'
+}

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

@@ -0,0 +1,7 @@
+export interface DyNTS_Bot_Channel<T_PlatformChannel = any> {
+  id: string;
+  name: string;
+  isTextBased: boolean;
+  isDM: boolean;
+  rawPlatformChannel: T_PlatformChannel;
+}

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

@@ -0,0 +1,8 @@
+import { DyNTS_Bot_Message } from './bot-message.interface';
+
+export interface DyNTS_Bot_Command<T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>> {
+  command: string;
+  description: string;
+  commandHandler: (message: T_PlatformMessage) => Promise<void>;
+  permissionNeeded?: (message: T_PlatformMessage) => Promise<boolean>;
+}

package/src/_modules/bot/_models/bot-global-settings.interface.ts

@@ -0,0 +1,87 @@
+import { DyNTS_Bot_Command } from './bot-command.interface';
+
+export interface DyNTS_Bot_Global_Settings {
+  /**
+   * this setting will set the debug level for the bot
+   * 
+   * 0 - no logs  
+   * 1 - errors sending to report channel  
+   * 2 - errors sending as response, will log events in console   
+   * 3 - errors sending as response, creating reports to report channel, debug events are in console (default)  
+   * 4 - errors and debug events are sending as response  
+   * 5 - all events are sending as response (that are set to send)  
+   * 6 - all debug logs are enabled  
+   *   
+   *   _
+   */
+  debugLevel: number;
+
+  allowedUsers: 'all' | string[];
+
+  messageSettings: {
+    /**
+     * this setting will set the time limit for message fetching
+     * so we will stop fetching messages sent later than this time
+     */
+    messageFetchTimeLimit: number;
+    /**
+     * this setting will set the count limit for message fetching
+     * so we will stop fetching messages after this count
+     */
+    messageFetchCountLimit: number;
+    /**
+     * this setting will set the delay for message sending,
+     * so we won't flood the channel too fast
+     */
+    messageSendDelay: number;
+
+    /**
+     * this setting will be used to skip answering to messages
+     * if the message contains any of these flags, the bot will not answer
+     * 
+     * @default [ '[BOT-SKIP]' ]
+     */
+    skipFlags: string[];
+  };
+
+  /**
+   * this setting will set the channel settings for the bot
+   */
+  channelSettings: {
+    /**
+     * this setting will set the name of the channel where the bot will send the reports
+     * 
+     * @default 'bot-report'
+     */
+    reportChannelName: string;
+
+    /**
+     * this setting will set the channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * it will be populated automatically from the default channels
+     */
+    allowedChannels: string[];
+    /**
+     * this setting will set if the bot can answer in Direct Messages Channels
+     * 
+     * @default false
+     */
+    dmIsAllowed: boolean;
+
+    /**
+     * this setting will set the default channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * @default [ 'bot-report' ]
+     */
+    defaultChannels: string[];
+  };
+
+  commandSettings: {
+    commandOperator: string;
+    commands: DyNTS_Bot_Command[];
+  };
+
+  allowBotsInteractEachOther: boolean;
+}

package/src/_modules/bot/_models/bot-last-mention-date.interface.ts

@@ -0,0 +1,6 @@
+export interface DyNTS_Bot_LastMentionDate {
+  memberId: string;
+  memberName: string;
+  allMentions: number;
+  lastMentionDate: Date | null;
+}

package/src/_modules/bot/_models/bot-last-message-date.interface.ts

@@ -0,0 +1,5 @@
+export interface DyNTS_Bot_LastMessageDate {
+  memberName: string;
+  allMessages: number;
+  lastMessageDate: Date | null;
+}

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

@@ -0,0 +1,14 @@
+export interface DyNTS_Bot_Message<T_PlatformMessage = any> {
+  id: string;
+  content: string;
+  authorId: string;
+  authorName: string;
+  authorDisplayName: string;
+  channelId: string;
+  channelName: string;
+  timestamp: number;
+  isBot: boolean;
+  replyToMessageId?: string;
+  mentions: string[]; // user IDs
+  rawPlatformMessage: T_PlatformMessage; // Original platform message for platform-specific operations
+}

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

@@ -0,0 +1,80 @@
+import { DyNTS_Bot_Message } from './bot-message.interface';
+import { DyNTS_Bot_Channel } from './bot-channel.interface';
+import { DyNTS_Bot_User } from './bot-user.interface';
+import { DyNTS_Bot_LastMessageDate } from './bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from './bot-last-mention-date.interface';
+import { DyNTS_Bot_Provider_Type } from '../_enums/bot-provider.enum';
+import { DyNTS_Bot_Global_Settings } from './bot-global-settings.interface';
+
+export interface DyNTS_Bot_Provider_Config extends DyNTS_Bot_Global_Settings {
+  provider: DyNTS_Bot_Provider_Type;
+  providerInstance?: DyNTS_Bot_Provider;
+  discord?: {
+    token: string;
+    guildId: string;
+    clientId: string;
+    oauth2Url: string;
+  };
+  slack?: {
+    token: string;
+    workspace: string;
+  };
+  teams?: {
+    appId: string;
+    appPassword: string;
+    tenantId: string;
+  };
+}
+
+export interface DyNTS_Bot_Provider<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>
+> {
+  // Initialization
+  initialize(config: DyNTS_Bot_Provider_Config): Promise<void>;
+  login(token: string): Promise<void>;
+  
+  // Channel operations
+  getChannelByName(name: string): Promise<T_PlatformChannel>;
+  sendMessageToChannelByName(channelName: string, message: string): Promise<T_PlatformMessage>;
+  getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<T_PlatformMessage[]>;
+  getLastMessageInChannel(channelName: string): Promise<T_PlatformMessage>;
+  clearChannel(channelId: string): Promise<void>;
+  
+  // Message operations
+  sendMessage(channelId: string, content: string): Promise<T_PlatformMessage>;
+  replyToMessage(messageId: string, channelId: string, content: string): Promise<T_PlatformMessage>;
+  sendTyping(channelId: string): Promise<void>;
+  fetchMessages(channelId: string, limit: number): Promise<T_PlatformMessage[]>;
+  fetchAllMessagesWithPaging(channelId: string, maxFetch?: number): Promise<T_PlatformMessage[]>;
+  deleteMessage(messageId: string, channelId: string): Promise<void>;
+  
+  // User operations
+  getUserByName(username: string): Promise<T_PlatformUser>;
+  getUserMention(userId: string): string;
+  readMembersInChannel(channelName: string): Promise<T_PlatformUser[]>;
+  readMemberNamesInChannel(channelName: string): Promise<string[]>;
+  
+  // Advanced message queries
+  getLastMessageSentBy(channelName: string, username: string): Promise<T_PlatformMessage>;
+  getLastMentionOf(channelName: string, username: string): Promise<T_PlatformMessage>;
+  readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]>;
+  readLastMessageWithMemberNamePingInIt(channelName: string, users: T_PlatformUser[]): Promise<DyNTS_Bot_LastMentionDate[]>;
+  
+  // Platform-specific features (optional, may return null/undefined for unsupported platforms)
+  getRoleByName?(roleName: string): any;
+  getRolePingByName?(roleName: string): Promise<string>;
+  getRolePingsByName?(roleNames: string[]): Promise<string>;
+  
+  // Event binding
+  onMessage(handler: (message: T_PlatformMessage, issuer: string) => void): void;
+  onReady(handler: () => void): void;
+  onError(handler: (error: Error) => void): void;
+  
+  // Metadata
+  getBotId(): string;
+  getBotDisplayName(): string;
+  getProviderName(): string;
+  isReady(): boolean;
+}

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>;