@futdevpro/nts-dynamo 1.15.157 → 1.15.163

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

@@ -1,158 +0,0 @@
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
-import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
-
-export abstract class DyNTS_Bot_Commands_ControlService extends DyNTS_SingletonService {
-
-  // the getInstance() should be implemented in the concrete child class
-  /* static getInstance(): DyNTS_Bot_Commands_ControlService {
-    return DyNTS_Bot_Commands_ControlService.getSingletonInstance();
-  } */
-
-  protected mainBot_CS: DyNTS_Bot_Main_ControlService;
-  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService;
-
-  
-  get defaultProvider(): DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any> {
-    return this.mainBot_CS.defaultProvider;
-  }
-
-  /* get provider(): DyNTS_Bot_MessagingProvider<any, any, any> {
-    return this.mainBot_CS?.provider;
-  } */
-
-  /* protected constructor() {
-    super();
-
-    if (!this.provider) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'constructor', 
-          new Error(
-            'Bot provider not yet initialized, ' +
-            'should only be called after DyNTS_Bot_Main_ControlService.start'
-          ), 
-          'system-init'
-        ),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-C00`,
-      })
-    }
-  } */
- 
-  async setup(issuer: string): Promise<void> {
-    try {
-      this.mainBot_CS = this.getMainBotControlService();
-
-      if (!this.mainBot_CS) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('setup', new Error('Main Bot Control Service not found'), issuer),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S01`,
-        })
-      }
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('setup', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S000`,
-      })
-    }
-  }
-
-  async start(issuer: string): Promise<void> {
-    try {
-      if (!this.defaultProvider) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('start', new Error('Bot provider not yet started'), issuer),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
-        })
-      }
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('start', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
-      })
-    }
-  }
-
-  async handleCommand<T_MessagingPlatformMessage extends any = any>(
-    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, 
-    issuer: string
-  ): Promise<void> {
-    try {
-      const botSettings: DyNTS_Bot_Global_Settings = DyNTS_global_settings.bot_settings;
-      let haveCommandOperator: boolean = false;
-      let msg: string = message.content.replace(
-        message.provider.getUserMention(message.provider.botId), ''
-        //`<@${this.mainBot_CS.botClientId}>`, ''
-      ).trim();
-
-      if (!botSettings?.commandSettings?.commandOperator) {
-        haveCommandOperator = true;
-      } else if (
-        msg.startsWith(botSettings.commandSettings.commandOperator)
-      ) {
-        haveCommandOperator = true;
-        msg = msg.replace(botSettings.commandSettings.commandOperator, '');
-      }
-
-      if (!haveCommandOperator) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'handleCommand', 
-            new Error('No command operator found in the message'), 
-            issuer
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC1`,
-        })
-      }
-
-      const commandExists = botSettings?.commandSettings?.commands?.find(
-        (command) => msg.startsWith(command.command)
-      );
-
-      if (!commandExists) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'handleCommand', 
-            new Error(`Command not found: "${msg.split(' ')[0]}"`), 
-            issuer
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC2`,
-        })
-      }
-
-      if (commandExists.permissionNeeded) {
-        const permissionNeeded = await commandExists.permissionNeeded(message);
-
-        if (!permissionNeeded) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'handleCommand', 
-              new Error('Permission needed'), 
-              issuer
-            ),
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC3`,
-          })
-        }
-      }
-
-      await commandExists.commandHandler(message);
-    } catch (error) {
-      message.provider.replyToMessage(
-        message,
-        `Error occurred while handling the command:\n` +
-        DyFM_Error.getAnyMessage(error)
-      );
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('handleCommand', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC0`,
-      })
-    }
-  }
-}

package/src/_modules/bot/_services/bot-io.control-service.spec.ts

@@ -1,285 +0,0 @@
-
-import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
-import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
-import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
-import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-class TestBotIOService extends DyNTS_Bot_IO_ControlService {
-  protected declare mainBot_CS: any;
-  protected getMainBotControlService(): any {
-    return {
-      defaultProvider: {
-        botId: 'bot-123',
-        botDisplayName: 'TestBot',
-      },
-    } as any;
-  }
-
-  protected getCommandsControlService(): DyNTS_Bot_Commands_ControlService {
-    return {
-      handleCommand: jasmine.createSpy('handleCommand').and.returnValue(Promise.resolve()),
-    } as any;
-  }
-
-  handleMessage = async (message: any, issuer: string): Promise<any> => {
-    return message;
-  };
-
-  static getInstance(): TestBotIOService {
-    return TestBotIOService.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_Bot_IO_ControlService', () => {
-  let service: TestBotIOService;
-
-  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 };
-    }
-  });
-
-  beforeEach(() => {
-    service = TestBotIOService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestBotIOService.getInstance();
-    const instance2 = TestBotIOService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestBotIOService);
-  });
-
-  describe('| defaultProvider', () => {
-    it('| should return default provider from main bot service', () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      expect(service.defaultProvider).toBeDefined();
-      expect(service.defaultProvider.botId).toBe('bot-123');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should setup main bot and commands services', async () => {
-      await service.setup('issuer-123');
-
-      expect((service as any).mainBot_CS).toBeDefined();
-      expect((service as any).commands_CS).toBeDefined();
-    });
-
-    it('| should throw error when main bot service not found', async () => {
-      const serviceWithoutMainBot = new (class extends TestBotIOService {
-        protected override getMainBotControlService(): any {
-          return null;
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutMainBot.setup('issuer-123')
-      ).toBeRejected();
-    });
-
-    it('| should throw error when commands service not found', async () => {
-      const serviceWithoutCommands = new (class extends TestBotIOService {
-        protected override getCommandsControlService(): any {
-          return null;
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutCommands.setup('issuer-123')
-      ).toBeRejected();
-    });
-  });
-
-  describe('| start', () => {
-    it('| should throw error when default provider not initialized', async () => {
-      const serviceWithoutProvider = new (class extends TestBotIOService {
-        protected override getMainBotControlService(): any {
-          return {
-            defaultProvider: null,
-          };
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutProvider.start('issuer-123')
-      ).toBeRejected();
-    });
-
-    it('| should succeed when default provider is initialized', async () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      await expectAsync(
-        service.start('issuer-123')
-      ).toBeResolved();
-    });
-  });
-
-  describe('| getMessageIsForBotToHandle', () => {
-    it('| should return false when bot not initialized', async () => {
-      const mockMessage = {
-        provider: null,
-        content: 'Test message',
-      } as any;
-
-      const result = await service.getMessageIsForBotToHandle(mockMessage, 'issuer-123');
-
-      expect(result).toBe(false);
-    });
-
-    it('| should return false when message has skip flags', async () => {
-      const mockMessage = {
-        provider: {
-          botId: 'bot-123',
-          botDisplayName: 'Bot',
-        },
-        content: '[BOT-SKIP] Test message',
-        authorId: 'user-123',
-        isBot: false,
-        channelName: 'test-channel',
-      } as any;
-      spyOn(DyNTS_global_settings, 'bot_settings').and.returnValue({
-        messageSettings: {
-          skipFlags: ['[BOT-SKIP]'],
-        },
-        channelSettings: {
-          allowedChannels: ['test-channel'],
-          defaultChannels: [],
-          dmIsAllowed: false,
-        },
-        allowedUsers: 'all',
-        debugLevel: 1,
-      } as any);
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      const result = await service.getMessageIsForBotToHandle(mockMessage, 'issuer-123');
-
-      expect(result).toBe(false);
-    });
-
-    it('| should return false when message is from bot and bots not allowed', async () => {
-      const mockMessage = {
-        provider: {
-          botId: 'bot-123',
-          botDisplayName: 'Bot',
-        },
-        content: 'Test message',
-        authorId: 'bot-456',
-        isBot: true,
-        channelName: 'test-channel',
-      } as any;
-      spyOn(DyNTS_global_settings, 'bot_settings').and.returnValue({
-        messageSettings: {
-          skipFlags: [],
-        },
-        channelSettings: {
-          allowedChannels: ['test-channel'],
-          defaultChannels: [],
-          dmIsAllowed: false,
-        },
-        allowedUsers: 'all',
-        allowBotsInteractEachOther: false,
-        debugLevel: 1,
-      } as any);
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      const result = await service.getMessageIsForBotToHandle(mockMessage, 'issuer-123');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('| handleIfCommand', () => {
-    it('| should handle command when message is a command', async () => {
-      const mockMessage = {
-        content: '!test',
-        provider: {
-          botId: 'bot-123',
-        },
-      } as any;
-      (service as any).commands_CS = (service as any).getCommandsControlService();
-      spyOn(service, 'isCommand').and.returnValue(Promise.resolve(true));
-
-      const result = await service.handleIfCommand(mockMessage, 'issuer-123');
-
-      expect(result).toBe(true);
-      expect((service as any).commands_CS.handleCommand).toHaveBeenCalledWith(mockMessage, 'issuer-123');
-    });
-
-    it('| should return false when message is not a command', async () => {
-      const mockMessage = {
-        content: 'Regular message',
-      } as any;
-      spyOn(service, 'isCommand').and.returnValue(Promise.resolve(false));
-
-      const result = await service.handleIfCommand(mockMessage, 'issuer-123');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('| isCommand', () => {
-    it('| should return true when message starts with command operator', async () => {
-      const mockMessage = {
-        content: '!test command',
-      } as any;
-      const orig = (DyNTS_global_settings as { bot_settings?: unknown }).bot_settings;
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = {
-        commandSettings: {
-          commandOperator: '!',
-          commands: [{ command: 'test' }],
-        },
-      };
-
-      const result = await service.isCommand(mockMessage, 'issuer-123');
-
-      expect(result).toBe(true);
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = orig;
-    });
-
-    it('| should return false when message does not start with command operator', async () => {
-      const mockMessage = {
-        content: 'regular message',
-      } as any;
-      const orig = (DyNTS_global_settings as { bot_settings?: unknown }).bot_settings;
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = {
-        commandSettings: {
-          commandOperator: '!',
-          commands: [],
-        },
-      };
-
-      const result = await service.isCommand(mockMessage, 'issuer-123');
-
-      expect(result).toBe(false);
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = orig;
-    });
-
-    it('| should return true when no command operator is set', async () => {
-      const mockMessage = {
-        content: 'test',
-      } as any;
-      const orig = (DyNTS_global_settings as { bot_settings?: unknown }).bot_settings;
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = {
-        commandSettings: {
-          commandOperator: '',
-          commands: [{ command: 'test' }],
-        },
-      };
-
-      const result = await service.isCommand(mockMessage, 'issuer-123');
-
-      expect(result).toBe(true);
-      (DyNTS_global_settings as { bot_settings: unknown }).bot_settings = orig;
-    });
-  });
-});
-