@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_modules/messaging/_services/msg-message.data-service.ts

@@ -1,129 +0,0 @@
-import { Request } from 'express';
-import { DyFM_Error, DyFM_DBFilter } from '@futdevpro/fsm-dynamo';
-import {
-  DyFM_Msg_Message,
-  DyFM_msgMessage_dataParams,
-  DyFM_Msg_Status,
-} from '@futdevpro/fsm-dynamo/messaging';
-
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-/**
- * Message Data Service
- * Handles CRUD operations for messages
- */
-export class DyNTS_Msg_Message_DataService extends DyNTS_DataService<DyFM_Msg_Message> {
-  
-  constructor(
-    set: {
-      message?: DyFM_Msg_Message;
-      issuer: string;
-    }
-  ) {
-    super(
-      new DyFM_Msg_Message(set?.message),
-      DyFM_msgMessage_dataParams,
-      set.issuer
-    );
-  }
-  
-  /**
-   * Get messages for a conversation
-   */
-  async getConversationMessages(
-    conversationId: string,
-    limit?: number,
-    skip?: number
-  ): Promise<DyFM_Msg_Message[]> {
-    try {
-      const maxLimit = DyNTS_global_settings.messaging_settings?.maxMessagesPerLoad || 50;
-      const actualLimit = limit && limit < maxLimit ? limit : maxLimit;
-      
-      await this.dataDBService
-        .find({ conversationId, __deleted: { $exists: false } } as DyFM_DBFilter<DyFM_Msg_Message>)
-        .then((res: DyFM_Msg_Message[]) => {
-          this.dataList = res
-            .sort((a, b) => (b.sentAt?.getTime() || 0) - (a.sentAt?.getTime() || 0))
-            .slice(skip || 0, (skip || 0) + actualLimit);
-        });
-      
-      return this.dataList;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('getConversationMessages', error),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-GCM`,
-        userMessage: 'Failed to retrieve conversation messages.',
-      });
-    }
-  }
-  
-  /**
-   * Mark message as delivered
-   */
-  async markAsDelivered(messageId: string): Promise<void> {
-    try {
-      const message = await this.getDataById(messageId);
-      
-      if (!message) {
-        throw new Error('Message not found');
-      }
-      
-      message.status = DyFM_Msg_Status.delivered;
-      message.deliveredAt = new Date();
-      
-      await this.saveData(message);
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('markAsDelivered', error),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-MAD`,
-        userMessage: 'Failed to mark message as delivered.',
-      });
-    }
-  }
-  
-  /**
-   * Mark message as read
-   */
-  async markAsRead(messageId: string, userId: string): Promise<void> {
-    try {
-      const message = await this.getDataById(messageId);
-      
-      if (!message) {
-        throw new Error('Message not found');
-      }
-      
-      message.status = DyFM_Msg_Status.read;
-      message.readAt = new Date();
-      
-      await this.saveData(message);
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('markAsRead', error),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-MAR`,
-        userMessage: 'Failed to mark message as read.',
-      });
-    }
-  }
-  
-  /**
-   * Get thread messages
-   */
-  async getThreadMessages(threadId: string): Promise<DyFM_Msg_Message[]> {
-    try {
-      await this.dataDBService
-        .find({ parentMessageId: threadId, __deleted: { $exists: false } } as DyFM_DBFilter<DyFM_Msg_Message>)
-        .then((res: DyFM_Msg_Message[]) => {
-          this.dataList = res.sort((a, b) => (a.sentAt?.getTime() || 0) - (b.sentAt?.getTime() || 0));
-        });
-      
-      return this.dataList;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('getThreadMessages', error),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-GTM`,
-        userMessage: 'Failed to retrieve thread messages.',
-      });
-    }
-  }
-}

package/src/_modules/messaging/_services/msg.controller.spec.ts

@@ -1,201 +0,0 @@
-
-import { DyNTS_Msg_Controller } from './msg.controller';
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-import { DyFM_msgModule_settings } from '@futdevpro/fsm-dynamo/messaging';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import type { DyNTS_AuthService } from '../../../_services/core/auth.service';
-
-describe('| DyNTS_Msg_Controller', () => {
-  let controller: DyNTS_Msg_Controller;
-  let mockAuthService: jasmine.SpyObj<{ getIssuerFromRequest: (req: unknown) => string }>;
-
-  beforeEach(() => {
-    mockAuthService = jasmine.createSpyObj('DyNTS_AuthService', ['getIssuerFromRequest']);
-    mockAuthService.getIssuerFromRequest.and.returnValue('user-123');
-    spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue(mockAuthService as unknown as DyNTS_AuthService);
-    controller = DyNTS_Msg_Controller.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = DyNTS_Msg_Controller.getInstance();
-    const instance2 = DyNTS_Msg_Controller.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(DyNTS_Msg_Controller);
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all messaging endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBeGreaterThanOrEqual(12);
-    });
-
-    it('| should setup getConversations endpoint', () => {
-      controller.setupEndpoints();
-
-      const getConversationsEndpoint = controller.endpoints.find(ep => ep.name === 'getConversations');
-      expect(getConversationsEndpoint).toBeDefined();
-      expect(getConversationsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getConversationsEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getConversations);
-      expect((getConversationsEndpoint as any)?.tasks).toBeDefined();
-      expect((getConversationsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getConversation endpoint', () => {
-      controller.setupEndpoints();
-
-      const getConversationEndpoint = controller.endpoints.find(ep => ep.name === 'getConversation');
-      expect(getConversationEndpoint).toBeDefined();
-      expect(getConversationEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getConversation);
-      expect((getConversationEndpoint as any)?.tasks).toBeDefined();
-      expect((getConversationEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup createConversation endpoint', () => {
-      controller.setupEndpoints();
-
-      const createConversationEndpoint = controller.endpoints.find(ep => ep.name === 'createConversation');
-      expect(createConversationEndpoint).toBeDefined();
-      expect(createConversationEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(createConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.createConversation);
-      expect((createConversationEndpoint as any)?.tasks).toBeDefined();
-      expect((createConversationEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getMessages endpoint', () => {
-      controller.setupEndpoints();
-
-      const getMessagesEndpoint = controller.endpoints.find(ep => ep.name === 'getMessages');
-      expect(getMessagesEndpoint).toBeDefined();
-      expect(getMessagesEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getMessagesEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getMessages);
-      expect((getMessagesEndpoint as any)?.tasks).toBeDefined();
-      expect((getMessagesEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup sendMessage endpoint', () => {
-      controller.setupEndpoints();
-
-      const sendMessageEndpoint = controller.endpoints.find(ep => ep.name === 'sendMessage');
-      expect(sendMessageEndpoint).toBeDefined();
-      expect(sendMessageEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(sendMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.sendMessage);
-      expect((sendMessageEndpoint as any)?.tasks).toBeDefined();
-      expect((sendMessageEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup editMessage endpoint', () => {
-      controller.setupEndpoints();
-
-      const editMessageEndpoint = controller.endpoints.find(ep => ep.name === 'editMessage');
-      expect(editMessageEndpoint).toBeDefined();
-      expect(editMessageEndpoint?.type).toBe(DyFM_HttpCallType.patch);
-      expect(editMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.editMessage);
-      expect((editMessageEndpoint as any)?.tasks).toBeDefined();
-      expect((editMessageEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup deleteMessage endpoint', () => {
-      controller.setupEndpoints();
-
-      const deleteMessageEndpoint = controller.endpoints.find(ep => ep.name === 'deleteMessage');
-      expect(deleteMessageEndpoint).toBeDefined();
-      expect(deleteMessageEndpoint?.type).toBe(DyFM_HttpCallType.delete);
-      expect(deleteMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.deleteMessage);
-      expect((deleteMessageEndpoint as any)?.tasks).toBeDefined();
-      expect((deleteMessageEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup markAsRead endpoint', () => {
-      controller.setupEndpoints();
-
-      const markAsReadEndpoint = controller.endpoints.find(ep => ep.name === 'markAsRead');
-      expect(markAsReadEndpoint).toBeDefined();
-      expect(markAsReadEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(markAsReadEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.markAsRead);
-      expect((markAsReadEndpoint as any)?.tasks).toBeDefined();
-      expect((markAsReadEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup addReaction endpoint', () => {
-      controller.setupEndpoints();
-
-      const addReactionEndpoint = controller.endpoints.find(ep => ep.name === 'addReaction');
-      expect(addReactionEndpoint).toBeDefined();
-      expect(addReactionEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(addReactionEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.addReaction);
-      expect((addReactionEndpoint as any)?.tasks).toBeDefined();
-      expect((addReactionEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup removeReaction endpoint', () => {
-      controller.setupEndpoints();
-
-      const removeReactionEndpoint = controller.endpoints.find(ep => ep.name === 'removeReaction');
-      expect(removeReactionEndpoint).toBeDefined();
-      expect(removeReactionEndpoint?.type).toBe(DyFM_HttpCallType.delete);
-      expect(removeReactionEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.removeReaction);
-      expect((removeReactionEndpoint as any)?.tasks).toBeDefined();
-      expect((removeReactionEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup updateConversation endpoint', () => {
-      controller.setupEndpoints();
-
-      const updateConversationEndpoint = controller.endpoints.find(ep => ep.name === 'updateConversation');
-      expect(updateConversationEndpoint).toBeDefined();
-      expect(updateConversationEndpoint?.type).toBe(DyFM_HttpCallType.patch);
-      expect(updateConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.updateConversation);
-      expect((updateConversationEndpoint as any)?.tasks).toBeDefined();
-      expect((updateConversationEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup deleteConversation endpoint', () => {
-      controller.setupEndpoints();
-
-      const deleteConversationEndpoint = controller.endpoints.find(ep => ep.name === 'deleteConversation');
-      expect(deleteConversationEndpoint).toBeDefined();
-      expect(deleteConversationEndpoint?.type).toBe(DyFM_HttpCallType.delete);
-      expect(deleteConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.deleteConversation);
-      expect((deleteConversationEndpoint as any)?.tasks).toBeDefined();
-      expect((deleteConversationEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup addParticipant endpoint', () => {
-      controller.setupEndpoints();
-
-      const addParticipantEndpoint = controller.endpoints.find(ep => ep.name === 'addParticipant');
-      expect(addParticipantEndpoint).toBeDefined();
-      expect(addParticipantEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(addParticipantEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.addParticipant);
-      expect((addParticipantEndpoint as any)?.tasks).toBeDefined();
-      expect((addParticipantEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup removeParticipant endpoint', () => {
-      controller.setupEndpoints();
-
-      const removeParticipantEndpoint = controller.endpoints.find(ep => ep.name === 'removeParticipant');
-      expect(removeParticipantEndpoint).toBeDefined();
-      expect(removeParticipantEndpoint?.type).toBe(DyFM_HttpCallType.delete);
-      expect(removeParticipantEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.removeParticipant);
-      expect((removeParticipantEndpoint as any)?.tasks).toBeDefined();
-      expect((removeParticipantEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getAgentProcess endpoint', () => {
-      controller.setupEndpoints();
-
-      const getAgentProcessEndpoint = controller.endpoints.find(ep => ep.name === 'getAgentProcess');
-      expect(getAgentProcessEndpoint).toBeDefined();
-      expect(getAgentProcessEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getAgentProcessEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getAgentProcess);
-      expect((getAgentProcessEndpoint as any)?.tasks).toBeDefined();
-      expect((getAgentProcessEndpoint as any)?.tasks?.length).toBe(1);
-    });
-  });
-});
-

package/src/_modules/messaging/_services/msg.controller.ts

@@ -1,370 +0,0 @@
-import { Request, Response } from 'express';
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-import {
-  DyFM_msgModule_settings,
-  DyFM_Msg_Message,
-  DyFM_Msg_Conversation,
-  DyFM_Msg_Status,
-  DyFM_Msg_Reaction,
-} from '@futdevpro/fsm-dynamo/messaging';
-
-import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-import { DyNTS_AuthService } from '../../../_services/core/auth.service';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import { DyNTS_Controller } from '../../../_services/route/controller.service';
-import { DyNTS_Msg_Message_DataService } from './msg-message.data-service';
-import { DyNTS_Msg_Conversation_DataService } from './msg-conversation.data-service';
-import { DyNTS_Msg_Events_Service } from './msg-events.service';
-import { DyNTS_Msg_Main_ControlService } from './msg-main.control-service';
-
-/**
- * Messaging Controller
- * Handles HTTP endpoints for messaging operations
- */
-export class DyNTS_Msg_Controller extends DyNTS_Controller {
-  
-  static getInstance(): DyNTS_Msg_Controller {
-    return DyNTS_Msg_Controller.getSingletonInstance();
-  }
-  
-  private authService: DyNTS_AuthService;
-  private eventsService = DyNTS_Msg_Events_Service.getInstance();
-  private msgControlService = DyNTS_Msg_Main_ControlService.getInstance();
-  
-  setupEndpoints(): void {
-    try {
-      this.authService = DyNTS_GlobalService.getAuthService();
-    } catch (error) {
-      // Auth service not available - use default auth service
-      const { DyNTS_Default_AuthService } = require('../defaults/_services/default-auth.service');
-      this.authService = DyNTS_Default_AuthService.getInstance();
-    }
-    
-    this.endpoints = [
-      // Get user's conversations
-      new DyNTS_Endpoint_Params({
-        name: 'getConversations',
-        type: DyFM_HttpCallType.get,
-        endpoint: DyFM_msgModule_settings.endPoints.getConversations,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const userId = this.authService.getIssuerFromRequest(req);
-            
-            const conversationService = new DyNTS_Msg_Conversation_DataService({
-              issuer,
-            });
-            
-            const conversations = await conversationService.getUserConversations(userId);
-            
-            res.send(conversations);
-          },
-        ],
-      }),
-      
-      // Get single conversation
-      new DyNTS_Endpoint_Params({
-        name: 'getConversation',
-        type: DyFM_HttpCallType.get,
-        endpoint: DyFM_msgModule_settings.endPoints.getConversation,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const conversationService = new DyNTS_Msg_Conversation_DataService({
-              issuer,
-            });
-            
-            await conversationService.getDataById(req.params.conversationId);
-            
-            res.send(conversationService.data);
-          },
-        ],
-      }),
-      
-       // Create conversation
-       new DyNTS_Endpoint_Params({
-         name: 'createConversation',
-         type: DyFM_HttpCallType.post,
-         endpoint: DyFM_msgModule_settings.endPoints.createConversation,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const creatorId = this.authService.getIssuerFromRequest(req);
-             
-             const conversation = await this.msgControlService.createConversation(
-               req.body,
-               creatorId,
-               issuer
-             );
-             
-             res.status(201).send(conversation);
-           },
-         ],
-       }),
-      
-      // Get messages for conversation
-      new DyNTS_Endpoint_Params({
-        name: 'getMessages',
-        type: DyFM_HttpCallType.get,
-        endpoint: DyFM_msgModule_settings.endPoints.getMessages,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const conversationId = req.params.conversationId;
-            const limit = req.query.limit ? parseInt(req.query.limit as string) : undefined;
-            const skip = req.query.skip ? parseInt(req.query.skip as string) : undefined;
-            
-            const messageService = new DyNTS_Msg_Message_DataService({
-              issuer,
-            });
-            
-            const messages = await messageService.getConversationMessages(
-              conversationId,
-              limit,
-              skip
-            );
-            
-            res.send(messages);
-          },
-        ],
-      }),
-      
-       // Send message
-       new DyNTS_Endpoint_Params({
-         name: 'sendMessage',
-         type: DyFM_HttpCallType.post,
-         endpoint: DyFM_msgModule_settings.endPoints.sendMessage,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const conversationId = req.params.conversationId;
-             const senderId = this.authService.getIssuerFromRequest(req);
-             
-             const message = await this.msgControlService.sendMessage(
-               conversationId,
-               req.body,
-               senderId,
-               issuer
-             );
-             
-             res.status(201).send(message);
-           },
-         ],
-       }),
-      
-      // Edit message
-      new DyNTS_Endpoint_Params({
-        name: 'editMessage',
-        type: DyFM_HttpCallType.patch,
-        endpoint: DyFM_msgModule_settings.endPoints.editMessage,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const messageId = req.params.messageId;
-            const userId = this.authService.getIssuerFromRequest(req);
-            
-            const message = await this.msgControlService.editMessage(
-              messageId,
-              req.body.content,
-              userId,
-              issuer
-            );
-            
-            res.send(message);
-          },
-        ],
-      }),
-      
-      // Delete message
-      new DyNTS_Endpoint_Params({
-        name: 'deleteMessage',
-        type: DyFM_HttpCallType.delete,
-        endpoint: DyFM_msgModule_settings.endPoints.deleteMessage,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const messageId = req.params.messageId;
-            const userId = this.authService.getIssuerFromRequest(req);
-            
-            await this.msgControlService.deleteMessage(
-              messageId,
-              userId,
-              issuer
-            );
-            
-            res.send({ success: true });
-          },
-        ],
-      }),
-      
-      // Mark messages as read
-      new DyNTS_Endpoint_Params({
-        name: 'markAsRead',
-        type: DyFM_HttpCallType.post,
-        endpoint: DyFM_msgModule_settings.endPoints.markAsRead,
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const userId = this.authService.getIssuerFromRequest(req);
-            const messageIds: string[] = req.body.messageIds || [];
-            
-            const result = await this.msgControlService.markMessagesAsRead(
-              messageIds,
-              userId,
-              issuer
-            );
-            
-            res.send(result);
-          },
-        ],
-      }),
-      
-       // Add reaction
-       new DyNTS_Endpoint_Params({
-         name: 'addReaction',
-         type: DyFM_HttpCallType.post,
-         endpoint: DyFM_msgModule_settings.endPoints.addReaction,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const messageId = req.params.messageId;
-             const { emoji } = req.body;
-             const userId = this.authService.getIssuerFromRequest(req);
-             
-             const message = await this.msgControlService.addReaction(
-               messageId,
-               emoji,
-               userId,
-               issuer
-             );
-             
-             res.send(message);
-           },
-         ],
-       }),
-       
-       // Remove reaction
-       new DyNTS_Endpoint_Params({
-         name: 'removeReaction',
-         type: DyFM_HttpCallType.delete,
-         endpoint: DyFM_msgModule_settings.endPoints.removeReaction,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const messageId = req.params.messageId;
-             const { emoji } = req.params;
-             const userId = this.authService.getIssuerFromRequest(req);
-             
-             const message = await this.msgControlService.removeReaction(
-               messageId,
-               emoji,
-               userId,
-               issuer
-             );
-             
-             res.send(message);
-           },
-         ],
-       }),
-       
-       // Update conversation
-       new DyNTS_Endpoint_Params({
-         name: 'updateConversation',
-         type: DyFM_HttpCallType.patch,
-         endpoint: DyFM_msgModule_settings.endPoints.updateConversation,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const conversationId = req.params.conversationId;
-             const userId = this.authService.getIssuerFromRequest(req);
-             
-             const conversation = await this.msgControlService.updateConversation(
-               conversationId,
-               req.body,
-               userId,
-               issuer
-             );
-             
-             res.send(conversation);
-           },
-         ],
-       }),
-       
-       // Delete conversation
-       new DyNTS_Endpoint_Params({
-         name: 'deleteConversation',
-         type: DyFM_HttpCallType.delete,
-         endpoint: DyFM_msgModule_settings.endPoints.deleteConversation,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const conversationId = req.params.conversationId;
-             const userId = this.authService.getIssuerFromRequest(req);
-             
-             await this.msgControlService.deleteConversation(
-               conversationId,
-               userId,
-               issuer
-             );
-             
-             res.send({ success: true });
-           },
-         ],
-       }),
-       
-       // Add participant
-       new DyNTS_Endpoint_Params({
-         name: 'addParticipant',
-         type: DyFM_HttpCallType.post,
-         endpoint: DyFM_msgModule_settings.endPoints.addParticipant,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const conversationId = req.params.conversationId;
-             const { userId: newUserId, role = 'member' } = req.body;
-             const requesterId = this.authService.getIssuerFromRequest(req);
-             
-             await this.msgControlService.addParticipant(
-               conversationId,
-               newUserId,
-               role,
-               requesterId,
-               issuer
-             );
-             
-             res.send({ success: true });
-           },
-         ],
-       }),
-       
-       // Remove participant
-       new DyNTS_Endpoint_Params({
-         name: 'removeParticipant',
-         type: DyFM_HttpCallType.delete,
-         endpoint: DyFM_msgModule_settings.endPoints.removeParticipant,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const conversationId = req.params.conversationId;
-             const userIdToRemove = req.params.userId;
-             const requesterId = this.authService.getIssuerFromRequest(req);
-             
-             await this.msgControlService.removeParticipant(
-               conversationId,
-               userIdToRemove,
-               requesterId,
-               issuer
-             );
-             
-             res.send({ success: true });
-           },
-         ],
-       }),
-       
-       // Get agent process
-       new DyNTS_Endpoint_Params({
-         name: 'getAgentProcess',
-         type: DyFM_HttpCallType.get,
-         endpoint: DyFM_msgModule_settings.endPoints.getAgentProcess,
-         tasks: [
-           async (req: Request, res: Response, issuer: string): Promise<void> => {
-             const messageId = req.params.messageId;
-             
-             const agentProcessSteps = await this.msgControlService.getAgentProcessSteps(
-               messageId,
-               issuer
-             );
-             
-             res.send(agentProcessSteps);
-           },
-         ],
-       }),
-    ];
-  }
-}