@futdevpro/nts-dynamo 1.15.84 → 1.15.86

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

@@ -1,12 +1,12 @@
-import { Message } from 'discord.js';
-
-
-
-
-export interface DyNTS_DiBo_Command {
-  command: string;
-  description: string;
-  commandHandler: (message: Message) => Promise<void>;
-  permissionNeeded?: (message: Message) => Promise<boolean>;
-}
-
+import { Message } from 'discord.js';
+
+
+
+
+export interface DyNTS_DiBo_Command {
+  command: string;
+  description: string;
+  commandHandler: (message: Message) => Promise<void>;
+  permissionNeeded?: (message: Message) => Promise<boolean>;
+}
+

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

@@ -1,98 +1,98 @@
-import { GatewayIntentBits, Partials } from 'discord.js';
-import { DyNTS_DiBo_Command } from './dibo-command.interface';
-
-export interface DyNTS_DiBo_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;
-
-  /**
-   * this setting will set the intents for the bot
-   */
-  intents: GatewayIntentBits[];
-
-  /**
-   * this setting will set the partials for the bot
-   */
-  partials: Partials[];
-
-  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_DiBo_Command[];
-  };
-
-  allowBotsInteractEachOther: boolean;
-}
+import { GatewayIntentBits, Partials } from 'discord.js';
+import { DyNTS_DiBo_Command } from './dibo-command.interface';
+
+export interface DyNTS_DiBo_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;
+
+  /**
+   * this setting will set the intents for the bot
+   */
+  intents: GatewayIntentBits[];
+
+  /**
+   * this setting will set the partials for the bot
+   */
+  partials: Partials[];
+
+  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_DiBo_Command[];
+  };
+
+  allowBotsInteractEachOther: boolean;
+}

package/src/_modules/discord-bot/_models/dibo-last-mention-date.inteface.ts

@@ -1,8 +1,8 @@
-
-
-export interface DyNTS_DiBo_LastMentionDate {
-  memberId: string
-  memberName: string
-  allMentions: number
-  lastMentionDate: Date
+
+
+export interface DyNTS_DiBo_LastMentionDate {
+  memberId: string
+  memberName: string
+  allMentions: number
+  lastMentionDate: Date
 }

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

@@ -1,6 +1,6 @@
-
-export interface DyNTS_DiBo_LastMessageDate {
-  memberName: string
-  allMessages: number
-  lastMessageDate: Date
-}
+
+export interface DyNTS_DiBo_LastMessageDate {
+  memberName: string
+  allMessages: number
+  lastMessageDate: Date
+}

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

@@ -1,154 +1,154 @@
-
-import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
-import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
-import { Message, Guild } from 'discord.js';
-import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
-
-class TestDiBoCommandsService extends DyNTS_DiBo_Commands_ControlService {
-  protected getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService {
-    return this.diAs_CS;
-  }
-
-  static getInstance(): TestDiBoCommandsService {
-    return TestDiBoCommandsService.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_DiBo_Commands_ControlService', () => {
-  let service: TestDiBoCommandsService;
-  let mockMain_CS: jasmine.SpyObj<DyNTS_DiBo_Main_ControlService>;
-  let mockGuild: jasmine.SpyObj<Guild>;
-  let mockMessage: jasmine.SpyObj<Message>;
-  let originalCommandSettings: typeof DyNTS_DiBo_global_settings.commandSettings;
-
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) {
-      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
-    }
-    if (!DyNTS_global_settings.env_settings) {
-      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
-    }
-    originalCommandSettings = { ...DyNTS_DiBo_global_settings.commandSettings };
-  });
-
-  afterEach(() => {
-    (DyNTS_DiBo_global_settings as { commandSettings: unknown }).commandSettings = originalCommandSettings;
-  });
-
-  beforeEach(() => {
-    mockGuild = jasmine.createSpyObj('Guild', [], {
-      id: 'guild-123',
-    });
-
-    mockMessage = jasmine.createSpyObj('Message', ['reply'], {
-      id: 'message-123',
-      content: '!test command',
-      author: {
-        id: 'user-123',
-      },
-    });
-
-    mockMain_CS = jasmine.createSpyObj('DyNTS_DiBo_Main_ControlService', [], {
-      discordServer: mockGuild,
-      client: {
-        user: {
-          id: 'bot-123',
-        },
-      },
-    });
-
-    service = new (TestDiBoCommandsService as any)();
-    (service as any).diAs_CS = mockMain_CS;
-  });
-
-  describe('| properties', () => {
-    it('| should return discordServer from main service', () => {
-      expect(service.discordServer).toBe(mockGuild);
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should setup service with main service', async () => {
-      await service.setup('test-issuer');
-
-      expect((service as any).diAs_CS).toBe(mockMain_CS);
-    });
-
-    it('| should throw error if main service not found', async () => {
-      (service as any).getMainDiscordBotControlService = () => null;
-
-      try {
-        await service.setup('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-CCS-S01');
-      }
-    });
-  });
-
-  describe('| start', () => {
-    it('| should start service successfully', async () => {
-      await service.start('test-issuer');
-
-      expect(service.discordServer).toBe(mockGuild);
-    });
-
-    it('| should throw error if discordServer not found', async () => {
-      (service as any).diAs_CS = null;
-
-      try {
-        await service.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-CCS-ST00');
-      }
-    });
-  });
-
-  describe('| handleCommand', () => {
-    it('| should handle command successfully', async () => {
-      const commandHandlerSpy = jasmine.createSpy('commandHandler').and.returnValue(Promise.resolve());
-      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
-        commandOperator: '!',
-        commands: [
-          {
-            command: 'test',
-            commandHandler: commandHandlerSpy,
-          },
-        ],
-      };
-
-      await service.handleCommand(mockMessage, 'test-issuer');
-
-      expect(commandHandlerSpy).toHaveBeenCalled();
-      expect(mockMessage.reply).not.toHaveBeenCalled();
-    });
-
-    it('| should handle command errors', async () => {
-      const commandError = new Error('Command handler error');
-      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
-        commandOperator: '!',
-        commands: [
-          {
-            command: 'test',
-            commandHandler: jasmine.createSpy('commandHandler').and.returnValue(Promise.reject(commandError)),
-          },
-        ],
-      };
-      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
-
-      try {
-        await service.handleCommand(mockMessage, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect(mockMessage.reply).toHaveBeenCalled();
-      }
-    });
-  });
-});
-
+
+import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
+import { Message, Guild } from 'discord.js';
+import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
+
+class TestDiBoCommandsService extends DyNTS_DiBo_Commands_ControlService {
+  protected getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService {
+    return this.diAs_CS;
+  }
+
+  static getInstance(): TestDiBoCommandsService {
+    return TestDiBoCommandsService.getSingletonInstance();
+  }
+}
+
+xdescribe('| DyNTS_DiBo_Commands_ControlService', () => {
+  let service: TestDiBoCommandsService;
+  let mockMain_CS: jasmine.SpyObj<DyNTS_DiBo_Main_ControlService>;
+  let mockGuild: jasmine.SpyObj<Guild>;
+  let mockMessage: jasmine.SpyObj<Message>;
+  let originalCommandSettings: typeof DyNTS_DiBo_global_settings.commandSettings;
+
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) {
+      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    }
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
+    }
+    originalCommandSettings = { ...DyNTS_DiBo_global_settings.commandSettings };
+  });
+
+  afterEach(() => {
+    (DyNTS_DiBo_global_settings as { commandSettings: unknown }).commandSettings = originalCommandSettings;
+  });
+
+  beforeEach(() => {
+    mockGuild = jasmine.createSpyObj('Guild', [], {
+      id: 'guild-123',
+    });
+
+    mockMessage = jasmine.createSpyObj('Message', ['reply'], {
+      id: 'message-123',
+      content: '!test command',
+      author: {
+        id: 'user-123',
+      },
+    });
+
+    mockMain_CS = jasmine.createSpyObj('DyNTS_DiBo_Main_ControlService', [], {
+      discordServer: mockGuild,
+      client: {
+        user: {
+          id: 'bot-123',
+        },
+      },
+    });
+
+    service = new (TestDiBoCommandsService as any)();
+    (service as any).diAs_CS = mockMain_CS;
+  });
+
+  describe('| properties', () => {
+    it('| should return discordServer from main service', () => {
+      expect(service.discordServer).toBe(mockGuild);
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should setup service with main service', async () => {
+      await service.setup('test-issuer');
+
+      expect((service as any).diAs_CS).toBe(mockMain_CS);
+    });
+
+    it('| should throw error if main service not found', async () => {
+      (service as any).getMainDiscordBotControlService = () => null;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-CCS-S01');
+      }
+    });
+  });
+
+  describe('| start', () => {
+    it('| should start service successfully', async () => {
+      await service.start('test-issuer');
+
+      expect(service.discordServer).toBe(mockGuild);
+    });
+
+    it('| should throw error if discordServer not found', async () => {
+      (service as any).diAs_CS = null;
+
+      try {
+        await service.start('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-CCS-ST00');
+      }
+    });
+  });
+
+  describe('| handleCommand', () => {
+    it('| should handle command successfully', async () => {
+      const commandHandlerSpy = jasmine.createSpy('commandHandler').and.returnValue(Promise.resolve());
+      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
+        commandOperator: '!',
+        commands: [
+          {
+            command: 'test',
+            commandHandler: commandHandlerSpy,
+          },
+        ],
+      };
+
+      await service.handleCommand(mockMessage, 'test-issuer');
+
+      expect(commandHandlerSpy).toHaveBeenCalled();
+      expect(mockMessage.reply).not.toHaveBeenCalled();
+    });
+
+    it('| should handle command errors', async () => {
+      const commandError = new Error('Command handler error');
+      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
+        commandOperator: '!',
+        commands: [
+          {
+            command: 'test',
+            commandHandler: jasmine.createSpy('commandHandler').and.returnValue(Promise.reject(commandError)),
+          },
+        ],
+      };
+      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
+
+      try {
+        await service.handleCommand(mockMessage, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect(mockMessage.reply).toHaveBeenCalled();
+      }
+    });
+  });
+});
+