@messenger-box/platform-server 10.0.3-alpha.7 → 10.0.3-alpha.72

package/lib/services/messenger-notification-service.js

@@ -1,76 +1,471 @@
-import {__decorate,__param,__metadata}from'tslib';import {omit}from'lodash-es';import {sub,compareAsc}from'date-fns';import fetch from'node-fetch';import {ServiceBroker}from'moleculer';import {injectable,inject}from'inversify';import {SERVER_TYPES,MoleculerServiceName,MailServiceAction,MailTemplateId,SmsServiceActions,AccountServiceAction,PostTypeEnum,RoomType}from'common';import {CommonType}from'@common-stack/core';import'@cdm-logger/core';import {config}from'../config/env-config.js';let MessengerNotificationService = class MessengerNotificationService {
+import {__decorate,__param,__metadata}from'tslib';import {omit}from'lodash-es';import {sub,compareAsc}from'date-fns';import fetch from'node-fetch';import {ServiceBroker}from'moleculer';import {injectable,inject}from'inversify';import {SERVER_TYPES,MoleculerServiceName,MailServiceAction,MailTemplateId,SmsServiceActions,AccountServiceAction,PostTypeEnum,RoomType}from'common/server';import {CommonType}from'@common-stack/core';import'@cdm-logger/core';import {DisposableCollection}from'@adminide-stack/core';import {config}from'../config/env-config.js';/**
+ * Messenger Notification Service Implementation
+ *
+ * This service handles comprehensive notification management within the messenger platform,
+ * providing operations for sending various types of notifications including email, SMS,
+ * push notifications, and Expo notifications across different messaging contexts.
+ *
+ * Key capabilities:
+ * - Multi-channel notification delivery (email, SMS, push, Expo)
+ * - Unread message notification scheduling and management
+ * - User preference-based notification filtering
+ * - Support service notification handling
+ * - Alert message notification broadcasting
+ * - Thread-based notification management
+ * - Real-time push notification integration
+ * - Template-based notification customization
+ * - Channel and post-based notification routing
+ * - User aggregation and preference management
+ *
+ * The service integrates with multiple external services through Moleculer broker
+ * and provides comprehensive error handling and logging for notification workflows.
+ */
+let MessengerNotificationService = class MessengerNotificationService {
   channelRepository;
   postRepository;
   postThreadRepository;
   countryRepository;
   broker;
-  logger;
+  toDispose = new DisposableCollection();
   users = {};
   userPreferences = {};
   supportServiceenvConfig = config?.SUPPORT_SERVICE_SETTINGS ?? null;
+  logger;
   constructor(channelRepository, postRepository, postThreadRepository, countryRepository, broker, logger) {
     this.channelRepository = channelRepository;
     this.postRepository = postRepository;
     this.postThreadRepository = postThreadRepository;
     this.countryRepository = countryRepository;
     this.broker = broker;
-    this.logger = logger;
+    this.logger = logger?.child({
+      className: 'MessengerNotificationService'
+    });
+  }
+  /**
+   * Disposes of resources used by the service
+   */
+  dispose() {
+    this.toDispose.dispose();
   }
+  /**
+   * Sets the support service configuration
+   *
+   * @description Updates the support service notification configuration for customized notifications
+   *
+   * @param {ISupportServiceConfig} config - Support service configuration
+   * @returns {Promise<void | Error>} - Void promise or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
   async setSupportServiceConfig(config) {
-    this.supportServiceenvConfig = {
-      ...this.supportServiceenvConfig,
-      ...config
-    };
+    try {
+      if (!config) {
+        return new Error('Support service configuration is required');
+      }
+      this.supportServiceenvConfig = {
+        ...this.supportServiceenvConfig,
+        ...config
+      };
+      this.logger.debug('Support service configuration updated', {
+        hasEmail: !!config.email,
+        hasTemplateId: !!config.templateId,
+        hasVariables: !!config.variables
+      });
+    } catch (error) {
+      this.logger.error('Error setting support service config: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while setting support service config');
+    }
   }
-  async getLatestMessageInAllChannels(unit, value) {
-    const today = new Date();
-    const lastDay = sub(today, {
-      [unit]: value
-    });
-    const channels = await this.channelRepository.model.aggregate([{
-      $match: {
-        lastPostAt: {
-          $gte: lastDay,
-          $lte: today
+  /**
+   * Sends notification for unread messages within a specified time frame
+   *
+   * @description Aggregates unread messages across channels and sends notifications
+   * to users based on their preferences within the specified duration
+   *
+   * @param {NotificationDurationUnitEnum} unit - Time unit for the duration
+   * @param {number} value - Number of time units to look back
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async sendNotificationOfUnreadMessages(unit, value) {
+    try {
+      if (!unit || typeof value !== 'number' || value <= 0) {
+        return new Error('Valid time unit and positive value are required');
+      }
+      this.logger.debug('Starting unread message notification process', {
+        unit,
+        value
+      });
+      const channels = await this.getLatestMessageInAllChannels(unit, value);
+      if (!channels || channels.length === 0) {
+        this.logger.debug('No channels with unread messages found');
+        return true;
+      }
+      const membersWithUnreadMessagesInChannels = this.groupByMember(channels);
+      const notificationPromises = Object.entries(membersWithUnreadMessagesInChannels).map(entry => this.sendNotificationToUser(entry));
+      await Promise.all(notificationPromises);
+      this.logger.debug('Unread message notifications sent successfully', {
+        channelCount: channels.length,
+        userCount: Object.keys(membersWithUnreadMessagesInChannels).length
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error sending unread message notifications: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending unread message notifications');
+    }
+  }
+  /**
+   * Sends Expo push notifications
+   *
+   * @description Sends push notifications through the Expo notification service
+   *
+   * @param {IExpoNotificationData} data - Notification data
+   * @returns {Promise<IExpoNotification | Error>} - Notification result or error
+   */
+  async sendPushNotificationsExpo(data) {
+    try {
+      if (!data) {
+        return new Error('Notification data is required');
+      }
+      if (!data.to || Array.isArray(data.to) && data.to.length === 0) {
+        return new Error('Notification recipients are required');
+      }
+      this.logger.debug('Sending Expo push notification', {
+        recipients: Array.isArray(data.to) ? data.to.length : 1,
+        hasTitle: !!data.title,
+        hasBody: !!data.body
+      });
+      const response = await fetch('https://exp.host/--/api/v2/push/send/', {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Accept-Encoding': 'gzip, deflate',
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        return new Error(`Expo notification service returned ${response.status}: ${response.statusText}`);
+      }
+      const result = await response.json();
+      this.logger.debug('Expo push notification sent successfully', {
+        status: result.status,
+        id: result.id
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error sending Expo push notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending Expo notification');
+    }
+  }
+  /**
+   * Sends Expo notification when a post is created
+   *
+   * @description Handles push notification logic for new posts with thread and channel support
+   *
+   * @param {IPost} post - The post that triggered the notification
+   * @param {IExpoNotificationBodyData} notificationData - Optional notification data override
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async sendExpoNotificationOnPost(post, notificationData) {
+    try {
+      if (!post) {
+        return new Error('Post data is required');
+      }
+      this.logger.debug('Processing post notification', {
+        postId: post.id,
+        channelId: post.channel,
+        hasNotificationData: !!notificationData
+      });
+      const currentPost = {
+        ...post
+      };
+      const notificationParams = notificationData && notificationData?.url ? notificationData : currentPost?.props?.notificationParams;
+      if (!notificationParams) {
+        this.logger.debug('No notification parameters found, skipping notification');
+        return false;
+      }
+      // Get thread participants if thread-based notification
+      const postThread = notificationParams?.thread?.id ? await this.getThreadWithParticipants(notificationParams?.thread?.id?.toString()) : null;
+      // Get channel members
+      const channel = await this.getChannelWithMembers(currentPost?.channel?.toString());
+      if (!channel) {
+        return new Error('Channel not found for post notification');
+      }
+      // Get sender information
+      const userId = notificationParams?.senderId?.toString() || currentPost?.editedBy?.toString();
+      const user = await this.getUser(userId);
+      if (!user) {
+        return new Error('User not found for post notification');
+      }
+      const {
+        givenName,
+        familyName,
+        username
+      } = user;
+      const fullName = givenName ? `${givenName} ${familyName}` : username || 'Message';
+      const notificationParamsOtherData = notificationParams?.other ?? {};
+      const title = notificationParams?.title || fullName;
+      const body = notificationParams?.body || (currentPost?.message === '' ? 'Sent a file' : currentPost?.message || 'New message');
+      const sound = notificationParamsOtherData?.sound ?? 'default';
+      // Collect notification tokens
+      let tokens = [];
+      if (postThread) {
+        tokens = this.extractNotificationTokens(postThread.participants?.filter(p => p?.user?.id !== userId) || [], 'participants');
+      } else {
+        tokens = this.extractNotificationTokens(channel.members?.filter(member => member?.user?.id !== userId) || [], 'members');
+      }
+      if (tokens.length === 0) {
+        this.logger.debug('No notification tokens found for recipients');
+        return false;
+      }
+      // Send the notification
+      const notificationResult = await this.sendPushNotificationsExpo({
+        to: tokens,
+        data: notificationParams,
+        title,
+        body,
+        sound
+      });
+      if (notificationResult instanceof Error) {
+        return notificationResult;
+      }
+      this.logger.debug('Post notification sent successfully', {
+        postId: post.id,
+        recipientCount: tokens.length
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error sending post notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending post notification');
+    }
+  }
+  /**
+   * Sends general notifications for a post
+   *
+   * @description Handles email and SMS notifications for posts with template support
+   *
+   * @param {IPost} post - The post that triggered the notification
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async sendNotificationOnPost(post) {
+    try {
+      if (!post) {
+        return new Error('Post data is required');
+      }
+      this.logger.debug('Processing post notification', {
+        postId: post.id
+      });
+      const currentPost = {
+        ...post
+      };
+      const template = currentPost?.props?.template ?? null;
+      // Extract template configuration
+      const guestTemplateId = template?.guest?.id ?? null;
+      const guestTemplateVariables = this.extractTemplateVariables(template?.guest?.variables);
+      const hostTemplateId = template?.host?.id ?? null;
+      const hostTemplateVariables = this.extractTemplateVariables(template?.host?.variables);
+      // Get guest user information
+      const guestId = guestTemplateVariables?.userId?.toString() || currentPost?.editedBy?.toString();
+      const user = await this.getUser(guestId);
+      if (!user) {
+        return new Error('Guest user not found');
+      }
+      const userPreferences = await this.getGlobalNotificationSettings(user.id);
+      const {
+        email,
+        sms,
+        browser
+      } = userPreferences?.global?.notification?.offlineMessages || {};
+      // Get channel and host information
+      const channel = await this.getChannelWithMembers(currentPost?.channel?.toString());
+      if (!channel) {
+        return new Error('Channel not found');
+      }
+      const channelOwner = this.findChannelOwner(channel);
+      const hostId = hostTemplateVariables?.userId?.toString() || channelOwner;
+      const owner = hostId ? await this.getUser(hostId) : null;
+      // Prepare notification content
+      const {
+        guestSubject,
+        hostSubject,
+        guestText,
+        hostText
+      } = this.prepareNotificationContent(currentPost, user, owner, guestTemplateVariables, hostTemplateVariables);
+      // Send notifications based on preferences
+      const notificationPromises = [];
+      if (email) {
+        // Send to guest
+        notificationPromises.push(this.sendMailOnPost(user, currentPost, channel, guestSubject, guestText, guestTemplateId, guestTemplateVariables));
+        // Send to host if exists
+        if (owner) {
+          notificationPromises.push(this.sendMailOnPost(owner, currentPost, channel, hostSubject, hostText, hostTemplateId, hostTemplateVariables));
         }
       }
-    }, {
-      $project: {
-        _id: true,
-        lastPostAt: true,
-        creator: true,
-        members: {
-          $filter: {
-            input: '$members',
-            as: 'item',
-            cond: {
-              $and: [{
-                $lte: ['$$item.lastViewedAt', '$lastPostAt']
-              }]
-            }
-          }
+      if (sms) {
+        notificationPromises.push(this.sendSmsOnPost(user, currentPost, guestText));
+        if (owner) {
+          notificationPromises.push(this.sendSmsOnPost(owner, currentPost, hostText));
         }
       }
-    }]);
-    const posts = await this.postRepository.getAll({
-      criteria: {
-        channel: {
-          $in: channels.map(({
-            _id
-          }) => _id)
-        },
-        createdAt: {
-          $in: channels.map(({
-            lastPostAt
-          }) => lastPostAt)
+      await Promise.all(notificationPromises);
+      this.logger.debug('Post notifications sent successfully', {
+        postId: post.id,
+        notificationTypes: {
+          email,
+          sms,
+          browser
         }
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error sending post notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending post notification');
+    }
+  }
+  /**
+   * Sends notifications for alert messages within a time frame
+   *
+   * @description Processes and sends notifications for alert-type messages
+   *
+   * @param {NotificationDurationUnitEnum} unit - Time unit for the duration
+   * @param {number} value - Number of time units to look back
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async sendNotificationOfAlertMessages(unit, value) {
+    try {
+      if (!unit || typeof value !== 'number' || value <= 0) {
+        return new Error('Valid time unit and positive value are required');
       }
-    });
-    return channels.map(channel => ({
-      ...channel,
-      // eslint-disable-next-line no-underscore-dangle
-      post: posts.find(post => post.channel.toString() === channel._id.toString())
-    }));
+      this.logger.debug('Processing alert message notifications', {
+        unit,
+        value
+      });
+      const posts = await this.getLatestAlertMessage(unit, value);
+      if (!posts || posts.length === 0) {
+        this.logger.debug('No alert messages found');
+        return true;
+      }
+      const notificationPromises = posts.map(post => this.sendNotificationOnPost(post));
+      const results = await Promise.all(notificationPromises);
+      // Check if any notifications failed
+      const failures = results.filter(result => result instanceof Error);
+      if (failures.length > 0) {
+        this.logger.warn(`${failures.length} alert notifications failed out of ${posts.length}`);
+      }
+      this.logger.debug('Alert message notifications processed', {
+        totalPosts: posts.length,
+        failures: failures.length
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error sending alert message notifications: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending alert notifications');
+    }
+  }
+  /**
+   * Sends notifications for unread service messages
+   *
+   * @description Handles notifications for support service channels
+   *
+   * @param {NotificationDurationUnitEnum} unit - Time unit for the duration
+   * @param {number} value - Number of time units to look back
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async sendNotificationOfUnreadServiceMessages(unit, value) {
+    try {
+      if (!unit || typeof value !== 'number' || value <= 0) {
+        return new Error('Valid time unit and positive value are required');
+      }
+      this.logger.debug('Processing service message notifications', {
+        unit,
+        value
+      });
+      const threads = await this.getServiceThreads(unit, value);
+      if (!threads || threads.length === 0) {
+        this.logger.debug('No service threads found');
+        return true;
+      }
+      const posts = await Promise.all(threads.map(thread => this.getServicePosts(thread)));
+      const validPosts = posts.filter(post => post !== null);
+      if (validPosts.length === 0) {
+        this.logger.debug('No valid service posts found');
+        return true;
+      }
+      const notificationPromises = validPosts.map(post => this.sendServiceNotificationOnPost(post));
+      const results = await Promise.all(notificationPromises);
+      const failures = results.filter(result => result instanceof Error);
+      if (failures.length > 0) {
+        this.logger.warn(`${failures.length} service notifications failed out of ${validPosts.length}`);
+      }
+      this.logger.debug('Service message notifications processed', {
+        totalThreads: threads.length,
+        validPosts: validPosts.length,
+        failures: failures.length
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error sending service message notifications: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending service notifications');
+    }
+  }
+  // Private helper methods
+  async getLatestMessageInAllChannels(unit, value) {
+    try {
+      const today = new Date();
+      const lastDay = sub(today, {
+        [unit]: value
+      });
+      const channels = await this.channelRepository.model.aggregate([{
+        $match: {
+          lastPostAt: {
+            $gte: lastDay,
+            $lte: today
+          }
+        }
+      }, {
+        $project: {
+          _id: true,
+          lastPostAt: true,
+          creator: true,
+          members: {
+            $filter: {
+              input: '$members',
+              as: 'item',
+              cond: {
+                $and: [{
+                  $lte: ['$$item.lastViewedAt', '$lastPostAt']
+                }]
+              }
+            }
+          }
+        }
+      }]);
+      const posts = await this.postRepository.getAll({
+        criteria: {
+          channel: {
+            $in: channels.map(({
+              _id
+            }) => _id)
+          },
+          createdAt: {
+            $in: channels.map(({
+              lastPostAt
+            }) => lastPostAt)
+          }
+        }
+      });
+      return channels.map(channel => ({
+        ...channel,
+        post: posts.find(post => post.channel.toString() === channel._id.toString())
+      }));
+    } catch (error) {
+      this.logger.error('Error getting latest messages in channels: %o', error);
+      return [];
+    }
   }
   groupByMember(channels) {
     return channels.reduce((acc, curr) => {
@@ -88,447 +483,434 @@ import {__decorate,__param,__metadata}from'tslib';import {omit}from'lodash-es';i
     }) => compareAsc(channelMessage.lastPostAt, lastViewedAt), []);
   }
   async sendMail(user, channels) {
-    this.logger.debug('Outgoing request to SendMail', {
-      user: this.users[user],
-      channels
-    });
-    const {
-      notificationEmail,
-      email,
-      username
-    } = this.users[user];
-    await this.broker.call(`${MoleculerServiceName.MailService}.${MailServiceAction.Send}`, {
-      request: {
-        topic: 'Unread Messages Notification',
-        to: notificationEmail || email,
-        templateId: MailTemplateId.MessageNotificationServiceId,
-        from: config.MAIL_SEND_DEFAULT_EMAIL,
-        subject: `You have Unread Messages in ${channels.length} chats`,
-        variables: {
-          text: `Hey ${username},\nYou have Unread Messages in ${channels.length} chats`,
-          user,
-          channel: channels
-        }
+    try {
+      this.logger.debug('Sending email notification', {
+        userId: user,
+        channelCount: channels.length
+      });
+      const userAccount = this.users[user];
+      if (!userAccount) {
+        throw new Error(`User account not found for user ${user}`);
       }
-    });
+      const {
+        notificationEmail,
+        email,
+        username
+      } = userAccount;
+      await this.broker.call(`${MoleculerServiceName.MailService}.${MailServiceAction.Send}`, {
+        request: {
+          topic: 'Unread Messages Notification',
+          to: notificationEmail || email,
+          templateId: MailTemplateId.MessageNotificationServiceId,
+          from: config.MAIL_SEND_DEFAULT_EMAIL,
+          subject: `You have Unread Messages in ${channels.length} chats`,
+          variables: {
+            text: `Hey ${username},\nYou have Unread Messages in ${channels.length} chats`,
+            user,
+            channel: channels
+          }
+        }
+      });
+    } catch (error) {
+      this.logger.error('Error sending email notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending email');
+    }
   }
   async sendText(user, channels) {
-    this.logger.debug('Outgoing request to SendSMS', {
-      user: this.users[user],
-      channels
-    });
-    // #Todo Get User Full Name and Phone Number
-    const {
-      username,
-      phoneNumber
-    } = this.users[user];
-    const [number] = phoneNumber;
-    if (!number) {
-      this.logger.debug('Outgoing request to SendSMS Skipped, reason No phoneNumber found', {
-        user: this.users[user],
-        channels
+    try {
+      this.logger.debug('Sending SMS notification', {
+        userId: user,
+        channelCount: channels.length
       });
+      const userAccount = this.users[user];
+      if (!userAccount) {
+        throw new Error(`User account not found for user ${user}`);
+      }
+      const {
+        username,
+        phoneNumber
+      } = userAccount;
+      const [number] = phoneNumber || [];
+      if (!number) {
+        this.logger.debug('SMS notification skipped - no phone number', {
+          userId: user
+        });
+        return;
+      }
+      await this.broker.call(`${MoleculerServiceName.SmsService}.${SmsServiceActions.Send}`, {
+        to: number,
+        body: `Hey ${username},\nYou have Unread Messages in ${channels.length} chats`
+      });
+    } catch (error) {
+      this.logger.error('Error sending SMS notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending SMS');
     }
-    await this.broker.call(`${MoleculerServiceName.SmsService}.${SmsServiceActions.Send}`, {
-      to: number,
-      body: `Hey ${username},\nYou have Unread Messages in ${channels.length} chats`
-    });
   }
   async sendPushNotifications(user, channels) {
-    // #Todo Dispatch Push notification once support is added
-    this.logger.debug('Outgoing request to SendPushNotification', {
-      user: this.users[user],
-      channels
+    this.logger.debug('Push notification placeholder called', {
+      userId: user,
+      channelCount: channels.length
     });
-    return Promise.resolve();
+    // Placeholder for future push notification implementation
   }
-  getGlobalNotificationSettings(user) {
-    // #Todo fetch from preferences
-    return Promise.resolve({
-      global: {
-        notification: {
-          offlineMessages: {
-            sms: true,
-            email: true,
-            browser: true
+  async getGlobalNotificationSettings(userId) {
+    try {
+      // Placeholder for preference service integration
+      return {
+        global: {
+          notification: {
+            offlineMessages: {
+              sms: true,
+              email: true,
+              browser: true
+            }
           }
         }
-      }
-    });
+      };
+    } catch (error) {
+      this.logger.error('Error getting notification settings: %o', error);
+      return {
+        global: {
+          notification: {
+            offlineMessages: {
+              sms: false,
+              email: false,
+              browser: false
+            }
+          }
+        }
+      };
+    }
   }
   async getUser(id) {
-    return this.broker.call(`${MoleculerServiceName.AccountUser}.${AccountServiceAction.FindAccountById}`, {
-      id
-    });
+    try {
+      if (!id) {
+        return null;
+      }
+      return await this.broker.call(`${MoleculerServiceName.AccountUser}.${AccountServiceAction.FindAccountById}`, {
+        id
+      });
+    } catch (error) {
+      this.logger.error('Error getting user: %o', error);
+      return null;
+    }
   }
   async fetchUsersForMembers(users) {
-    return Promise.all(users.filter(user => !Object.keys(this.users).includes(user)).map(async user => {
-      this.users[user] = await this.getUser(user);
-      this.userPreferences[user] = await this.getGlobalNotificationSettings(user);
-    }));
+    try {
+      const missingUsers = users.filter(user => !Object.keys(this.users).includes(user));
+      await Promise.all(missingUsers.map(async user => {
+        const userAccount = await this.getUser(user);
+        if (userAccount) {
+          this.users[user] = userAccount;
+          this.userPreferences[user] = await this.getGlobalNotificationSettings(user);
+        }
+      }));
+    } catch (error) {
+      this.logger.error('Error fetching users: %o', error);
+    }
   }
   async sendNotificationToUser([user, channels]) {
-    await this.fetchUsersForMembers([user, ...channels.map(({
-      post
-    }) => post.editedBy.toString())]);
-    const {
-      email,
-      sms,
-      browser
-    } = this.userPreferences[user]?.global?.notification?.offlineMessages || {};
-    const filteredChannels = channels.filter(({
-      post
-    }) => user !== post.editedBy.toString());
-    if (filteredChannels?.length === 0) {
-      return;
-    }
-    if (email) {
-      await this.sendMail(user, filteredChannels);
-    }
-    if (sms) {
-      await this.sendText(user, filteredChannels);
-    }
-    if (browser) {
-      await this.sendPushNotifications(user, filteredChannels);
+    try {
+      await this.fetchUsersForMembers([user, ...channels.map(({
+        post
+      }) => post.editedBy.toString())]);
+      const userPrefs = this.userPreferences[user];
+      const {
+        email,
+        sms,
+        browser
+      } = userPrefs?.global?.notification?.offlineMessages || {};
+      const filteredChannels = channels.filter(({
+        post
+      }) => user !== post.editedBy.toString());
+      if (filteredChannels.length === 0) {
+        return;
+      }
+      const notificationPromises = [];
+      if (email) {
+        notificationPromises.push(this.sendMail(user, filteredChannels));
+      }
+      if (sms) {
+        notificationPromises.push(this.sendText(user, filteredChannels));
+      }
+      if (browser) {
+        notificationPromises.push(this.sendPushNotifications(user, filteredChannels));
+      }
+      await Promise.all(notificationPromises);
+    } catch (error) {
+      this.logger.error('Error sending notification to user: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending user notification');
     }
   }
-  async sendNotificationOfUnreadMessages(unit, value) {
-    const channels = await this.getLatestMessageInAllChannels(unit, value);
-    const membersWithUnreadMessagesInChannels = this.groupByMember(channels);
-    await Promise.all(Object.entries(membersWithUnreadMessagesInChannels).map(this.sendNotificationToUser.bind(this)));
-  }
-  async sendPushNotificationsExpo(data) {
-    this.logger.debug('Outgoing request to ExpoPushNotification');
-    const response = await fetch('https://exp.host/--/api/v2/push/send/', {
-      method: 'POST',
-      headers: {
-        Accept: 'application/json',
-        'Accept-Encoding': 'gzip, deflate',
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify(data)
-    });
-    const result = await response.json();
-    this.logger.debug('ExpoPushNotification response', result);
-    return result;
-  }
   async getThreadWithParticipants(id) {
-    const thread = await this.postThreadRepository.model.findOne({
-      _id: id
-    }).lean();
-    const participants = await Promise.all({
-      ...thread
-    }?.participants?.map(async m => ({
-      ...m,
-      user: await this.getUser(m?.user?.toString())
-    })));
-    const threadWithParticipants = await Promise.all([{
-      ...thread,
-      participants: participants
-    }]);
-    return threadWithParticipants?.[0];
+    try {
+      const thread = await this.postThreadRepository.model.findOne({
+        _id: id
+      }).lean();
+      if (!thread) {
+        return null;
+      }
+      const participants = await Promise.all((thread.participants || []).map(async m => ({
+        ...m,
+        user: await this.getUser(m?.user?.toString())
+      })));
+      return {
+        ...thread,
+        participants
+      };
+    } catch (error) {
+      this.logger.error('Error getting thread with participants: %o', error);
+      return null;
+    }
   }
   async getChannelWithMembers(id) {
-    const channel = await this.channelRepository.model.findOne({
-      _id: id
-    }).lean();
-    const channelMembers = await Promise.all({
-      ...channel
-    }?.members?.map(async m => ({
-      ...m,
-      user: await this.getUser(m?.user?.toString())
-    })));
-    const channelWithMembers = await Promise.all([{
-      ...channel,
-      members: channelMembers
-    }]);
-    return channelWithMembers?.[0];
+    try {
+      const channel = await this.channelRepository.model.findOne({
+        _id: id
+      }).lean();
+      if (!channel) {
+        return null;
+      }
+      const members = await Promise.all((channel.members || []).map(async m => ({
+        ...m,
+        user: await this.getUser(m?.user?.toString())
+      })));
+      return {
+        ...channel,
+        members
+      };
+    } catch (error) {
+      this.logger.error('Error getting channel with members: %o', error);
+      return null;
+    }
   }
-  async sendExpoNotificationOnPost(post, notificationData) {
-    this.logger.debug('sendExpoNotificationOnPost');
-    const currentPost = {
-      ...post
-    };
-    const notificationParams = notificationData && notificationData?.url ? notificationData : currentPost?.props?.notificationParams;
-    const postThread = notificationParams?.thread?.id ? await this.getThreadWithParticipants(notificationParams?.thread?.id?.toString()) : null;
-    const channel = await this.getChannelWithMembers(currentPost?.channel?.toString());
-    const userId = notificationParams?.senderId?.toString() || currentPost?.editedBy?.toString();
-    const user = await this.getUser(userId);
-    const {
-      givenName,
-      familyName,
-      username
-    } = user;
-    const fullName = givenName ? givenName + ' ' + familyName : '';
-    const notificationParamsOtherData = notificationParams?.other ?? null;
-    const title = notificationParams && notificationParams?.title ? notificationParams?.title : fullName ? fullName : 'Message';
-    const body = notificationParams && notificationParams?.body ? notificationParams?.body : currentPost?.message == '' ? 'Send a file' : currentPost?.message;
-    const sound = notificationParamsOtherData?.sound ?? 'default';
-    let tokens;
-    if (postThread) {
-      tokens = postThread?.participants?.filter(p => p?.user?.id != userId)?.map(m => m?.user?.tokens?.filter(t => t?.type == 'EXPO_NOTIFICATION_TOKEN')?.map(et => et?.token) ?? [])?.flat(1)?.filter(t => t)?.filter((value, index, array) => array.indexOf(value) === index) ?? [];
-    } else {
-      tokens = channel?.members?.filter(member => member?.user?.id != userId)?.map(m => m?.user?.tokens?.filter(t => t?.type == 'EXPO_NOTIFICATION_TOKEN')?.map(et => et?.token) ?? [])?.flat(1)?.filter(t => t)?.filter((value, index, array) => array.indexOf(value) === index) ?? [];
+  extractNotificationTokens(entities, entityType) {
+    try {
+      return entities.map(entity => entity?.user?.tokens?.filter(t => t?.type === 'EXPO_NOTIFICATION_TOKEN')?.map(et => et?.token) || []).flat().filter(token => token).filter((value, index, array) => array.indexOf(value) === index);
+    } catch (error) {
+      this.logger.error(`Error extracting notification tokens from ${entityType}: %o`, error);
+      return [];
     }
-    if (tokens?.length > 0 && notificationParams) {
-      //this.logger.debug('sendExpoNotif tokens', tokens);
-      // const data: IExpoNotificationData = {
-      //     to: tokens,
-      //     data: notificationParams,
-      //     title,
-      //     body,
-      //     sound,
-      // };
-      const data = {
-        to: tokens,
-        data: notificationParams,
-        title,
-        body,
-        sound
+  }
+  extractTemplateVariables(variables) {
+    try {
+      return variables && typeof variables === 'object' && variables.constructor === Object ? {
+        ...variables
+      } : null;
+    } catch (error) {
+      this.logger.error('Error extracting template variables: %o', error);
+      return null;
+    }
+  }
+  findChannelOwner(channel) {
+    try {
+      return channel?.members?.filter(m => m?.roles === 'OWNER')?.map(u => u?.user?.toString())?.[0] || null;
+    } catch (error) {
+      this.logger.error('Error finding channel owner: %o', error);
+      return null;
+    }
+  }
+  prepareNotificationContent(post, user, owner, guestVariables, hostVariables) {
+    try {
+      // Prepare subject and content based on post properties
+      const postPropsAttachmentKeys = post?.props?.attachment ? Object.keys(post?.props?.attachment) : null;
+      const attachmentRefKey = postPropsAttachmentKeys?.find(key => key?.toLowerCase() === post?.props?.ref?.toLowerCase());
+      const refType = attachmentRefKey ? post?.props?.attachment[attachmentRefKey]?.type?.toLowerCase() : ' Notification';
+      const subject = post?.props?.ref ? `${post.props.ref.charAt(0).toUpperCase() + post.props.ref.slice(1)} ${refType.charAt(0).toUpperCase() + refType.slice(1)}` : 'You have Unread Messages in 1 chats';
+      const userName = user.givenName && user.familyName ? `${user.givenName} ${user.familyName}` : user.username || 'User';
+      const ownerName = owner?.givenName && owner?.familyName ? `${owner.givenName} ${owner.familyName}` : owner?.username || 'Owner';
+      return {
+        guestSubject: guestVariables?.subject || subject,
+        hostSubject: hostVariables?.subject || subject,
+        guestText: guestVariables?.bodyText || `Hi ${userName}, ${post?.message}`,
+        hostText: hostVariables?.bodyText || `Hi ${ownerName}, ${post?.message}`
       };
-      await this.sendPushNotificationsExpo(data);
-      return true;
-    } else return false;
+    } catch (error) {
+      this.logger.error('Error preparing notification content: %o', error);
+      return {
+        guestSubject: 'Notification',
+        hostSubject: 'Notification',
+        guestText: 'You have a new message',
+        hostText: 'You have a new message'
+      };
+    }
   }
   async sendMailOnPost(user, post, channel, subject, text, templateId = null, variables = null, recipientMail = null) {
-    this.logger.debug('Outgoing request to SendMail', {
-      user: user,
-      post
-    });
-    const {
-      notificationEmail,
-      email
-    } = user;
-    const topic = subject;
-    await this.broker.call(`${MoleculerServiceName.MailService}.${MailServiceAction.Send}`, {
-      request: {
-        topic: topic,
-        to: recipientMail || notificationEmail || email,
-        templateId: templateId || MailTemplateId.MessageNotificationServiceId,
-        namespace: config.NAMESPACE,
-        from: config.MAIL_SEND_DEFAULT_EMAIL,
-        subject,
-        variables: variables || {
-          text,
-          user,
-          post,
-          channel
+    try {
+      this.logger.debug('Sending mail notification for post', {
+        userId: user.id,
+        postId: post.id,
+        hasTemplate: !!templateId
+      });
+      const {
+        notificationEmail,
+        email
+      } = user;
+      await this.broker.call(`${MoleculerServiceName.MailService}.${MailServiceAction.Send}`, {
+        request: {
+          topic: subject,
+          to: recipientMail || notificationEmail || email,
+          templateId: templateId || MailTemplateId.MessageNotificationServiceId,
+          namespace: config.NAMESPACE,
+          from: config.MAIL_SEND_DEFAULT_EMAIL,
+          subject,
+          variables: variables || {
+            text,
+            user,
+            post,
+            channel
+          }
         }
-      }
-    });
-  }
-  async sendSmsOnPost(user, post, text) {
-    this.logger.debug('Outgoing request to SendSMS', {
-      user,
-      post
-    });
-    const {
-      username,
-      givenName,
-      familyName,
-      phoneNumber
-    } = user;
-    const [number] = phoneNumber;
-    const {
-      countryCode,
-      phoneNumber: mobile
-    } = number;
-    const countryData = await this.countryRepository.model.find({
-      _id: countryCode
-    });
-    const [country] = countryData;
-    const {
-      phone_code
-    } = country;
-    const mobileWithCountryCode = phone_code + mobile;
-    if (!mobileWithCountryCode) {
-      this.logger.debug('Outgoing request to SendSMS Skipped, reason No phoneNumber found', {
-        user: user,
-        post
       });
+    } catch (error) {
+      this.logger.error('Error sending mail for post: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending mail');
     }
-    await this.broker.call(`${MoleculerServiceName.SmsService}.${SmsServiceActions.Send}`, {
-      to: mobileWithCountryCode,
-      body: text
-    });
   }
-  async sendNotificationOnPost(post) {
-    const currentPost = {
-      ...post
-    };
-    const template = currentPost?.props?.template ?? null;
-    const guestTemplateId = template ? template?.guest?.id ?? null : null;
-    const guestTemlateVarables = template && template?.guest?.variables && typeof template?.guest?.variables === 'object' && template?.guest?.variables.constructor === Object ? {
-      ...template?.guest?.variables
-    } : null;
-    const hostTemplateId = template ? template?.host?.id ?? null : null;
-    const hostTemlateVarables = template && template?.host?.variables && typeof template?.host?.variables === 'object' && template?.host?.variables.constructor === Object ? {
-      ...template?.host?.variables
-    } : null;
-    const guestId = guestTemlateVarables?.userId?.toString() || currentPost?.editedBy?.toString();
-    const user = await this.getUser(guestId);
-    const {
-      givenName,
-      familyName,
-      username
-    } = user;
-    const userPreferences = await this.getGlobalNotificationSettings(user);
-    const {
-      email,
-      sms,
-      browser
-    } = userPreferences?.global?.notification?.offlineMessages || {};
-    const channel = await this.channelRepository.model.findOne({
-      _id: currentPost?.channel
-    });
-    const channelOwner = channel?.members?.filter(m => m?.roles == 'OWNER')?.map(u => u?.user?.toString())?.[0] ?? null;
-    const hostId = hostTemlateVarables?.userId?.toString() || channelOwner;
-    const owner = hostId ? await this.getUser(hostId) : null;
-    const {
-      givenName: ownerGivenName,
-      familyName: ownerFamilyName,
-      username: ownerUserName
-    } = owner;
-    const postPropsAttachmentKeys = currentPost?.props?.attachment ? Object.keys(currentPost?.props?.attachment) : null;
-    const attachmentRefKey = postPropsAttachmentKeys ? Array.isArray(postPropsAttachmentKeys) ? postPropsAttachmentKeys.filter(v => v == currentPost?.props?.ref.toLowerCase())[0] : Object.keys(currentPost?.props?.attachment).find(key => key?.toLowerCase() === currentPost?.props?.ref?.toLowerCase()) : null;
-    const refType = attachmentRefKey ? currentPost?.props?.attachment[attachmentRefKey]?.type?.toLowerCase() : ' Notification';
-    currentPost?.props?.ref?.toLowerCase()?.charAt(0)?.toUpperCase() + currentPost?.props?.ref?.toLowerCase()?.slice(1);
-    refType?.toLowerCase()?.charAt(0)?.toUpperCase() + refType?.toLowerCase()?.slice(1);
-    const subject = currentPost?.props?.ref ? `${currentPost.props.ref.toLowerCase().charAt(0).toUpperCase() + currentPost.props.ref.toLowerCase().slice(1)} ${refType.toLowerCase().charAt(0).toUpperCase() + refType.toLowerCase().slice(1)}` : 'You have Unread Messages in 1 chats';
-    const guestSubject = guestTemlateVarables?.subject || subject;
-    const hostSubject = hostTemlateVarables?.subject || subject;
-    const userName = givenName + ' ' + familyName || username;
-    const userText = `Hi ${userName}, ${currentPost?.message}`;
-    const ownerName = ownerGivenName + ' ' + ownerFamilyName || ownerUserName;
-    const ownerText = `Hi ${ownerName}, ${currentPost?.message}`;
-    const guestText = guestTemlateVarables?.bodyText || userText;
-    const hostText = hostTemlateVarables?.bodyText || ownerText;
-    if (email) {
-      if (guestTemlateVarables && !guestTemlateVarables.hasOwnProperty('text')) guestTemlateVarables.text = guestText;
-      if (guestTemlateVarables && !guestTemlateVarables.hasOwnProperty('user')) guestTemlateVarables.user = user;
-      if (guestTemlateVarables && !guestTemlateVarables.hasOwnProperty('post')) guestTemlateVarables.post = currentPost;
-      if (guestTemlateVarables && !guestTemlateVarables.hasOwnProperty('channel')) guestTemlateVarables.channel = channel;
-      await this.sendMailOnPost(user, currentPost, channel, guestSubject, guestText, guestTemplateId, guestTemlateVarables);
-      if (owner) {
-        if (hostTemlateVarables && !hostTemlateVarables.hasOwnProperty('text')) hostTemlateVarables.text = hostText;
-        if (hostTemlateVarables && !hostTemlateVarables.hasOwnProperty('user')) hostTemlateVarables.user = owner;
-        if (hostTemlateVarables && !hostTemlateVarables.hasOwnProperty('post')) hostTemlateVarables.post = currentPost;
-        if (hostTemlateVarables && !hostTemlateVarables.hasOwnProperty('channel')) hostTemlateVarables.channel = channel;
-        await this.sendMailOnPost(owner, currentPost, channel, hostSubject, hostText, hostTemplateId, hostTemlateVarables);
+  async sendSmsOnPost(user, post, text) {
+    try {
+      this.logger.debug('Sending SMS notification for post', {
+        userId: user.id,
+        postId: post.id
+      });
+      const {
+        phoneNumber
+      } = user;
+      const [number] = phoneNumber || [];
+      if (!number) {
+        this.logger.debug('SMS notification skipped - no phone number', {
+          userId: user.id
+        });
+        return;
       }
-    }
-    if (sms) {
-      await this.sendSmsOnPost(user, currentPost, guestText);
-      if (owner) {
-        await this.sendSmsOnPost(owner, currentPost, hostText);
+      const {
+        countryCode,
+        phoneNumber: mobile
+      } = number;
+      const countryData = await this.countryRepository.model.find({
+        _id: countryCode
+      });
+      const [country] = countryData || [];
+      if (!country) {
+        throw new Error('Country data not found for phone number');
       }
+      const {
+        phone_code
+      } = country;
+      const mobileWithCountryCode = phone_code + mobile;
+      await this.broker.call(`${MoleculerServiceName.SmsService}.${SmsServiceActions.Send}`, {
+        to: mobileWithCountryCode,
+        body: text
+      });
+    } catch (error) {
+      this.logger.error('Error sending SMS for post: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending SMS');
     }
-    return true;
   }
   async getLatestAlertMessage(unit, value) {
-    const today = new Date();
-    const lastDay = sub(today, {
-      [unit]: value
-    });
-    const filteredPosts = await this.postRepository.model.aggregate([{
-      $match: {
-        type: PostTypeEnum.Alert,
-        updatedAt: {
-          $gte: lastDay,
-          $lte: today
+    try {
+      const today = new Date();
+      const lastDay = sub(today, {
+        [unit]: value
+      });
+      const filteredPosts = await this.postRepository.model.aggregate([{
+        $match: {
+          type: PostTypeEnum.Alert,
+          updatedAt: {
+            $gte: lastDay,
+            $lte: today
+          }
         }
-      }
-    }]);
-    const posts = filteredPosts?.map(p => {
-      let post = {
-        ...p
-      };
-      post.editedBy = post?.editedBy?.toString();
-      return post;
-    }) ?? [];
-    return posts;
-  }
-  async sendNotificationOfAlertMessages(unit, value) {
-    const posts = await this.getLatestAlertMessage(unit, value);
-    if (posts && posts?.length > 0) await Promise.all(posts.map(this.sendNotificationOnPost.bind(this)));
+      }]);
+      return filteredPosts?.map(p => ({
+        ...p,
+        editedBy: p?.editedBy?.toString()
+      })) || [];
+    } catch (error) {
+      this.logger.error('Error getting latest alert messages: %o', error);
+      return [];
+    }
   }
   async sendServiceNotificationOnPost(post) {
-    const currentPost = {
-      ...post
-    };
-    const channel = await this.channelRepository.model.findOne({
-      _id: currentPost?.channel
-    });
-    const hostId = channel?.members?.filter(m => m?.roles == 'OWNER')?.map(u => u?.user?.toString())?.[0] ?? null;
-    const userId = hostId && currentPost?.editedBy?.toString() != hostId ? hostId : null;
-    const supportServiceConfig = this?.supportServiceenvConfig ?? null;
-    if (userId && supportServiceConfig.email) {
+    try {
+      const currentPost = {
+        ...post
+      };
+      const channel = await this.getChannelWithMembers(currentPost?.channel?.toString());
+      if (!channel) {
+        return new Error('Channel not found for service notification');
+      }
+      const hostId = this.findChannelOwner(channel);
+      const userId = hostId && currentPost?.editedBy?.toString() !== hostId ? hostId : null;
+      if (!userId || !this.supportServiceenvConfig?.email) {
+        this.logger.debug('Service notification skipped - no recipient or config');
+        return;
+      }
       const postUserId = currentPost?.editedBy?.toString();
       const postUser = await this.getUser(postUserId);
-      const {
-        givenName: postUserGivenName,
-        familyName: postUserFamilyname,
-        username: postUserUsername
-      } = postUser;
-      const postUserFullName = postUserGivenName + ' ' + postUserFamilyname || postUserUsername;
       const user = await this.getUser(userId);
-      const {
-        givenName,
-        familyName,
-        username,
-        notificationEmail,
-        email
-      } = user;
+      if (!postUser || !user) {
+        return new Error('Required users not found for service notification');
+      }
+      const postUserFullName = postUser.givenName && postUser.familyName ? `${postUser.givenName} ${postUser.familyName}` : postUser.username || 'User';
+      const userName = user.givenName && user.familyName ? `${user.givenName} ${user.familyName}` : user.username || 'User';
       const subject = 'You have Unread Messages in support service chat';
-      // const userText = `Hi ${userName},  ${postUserFullName} sent you ${currentPost?.message}`;
-      const userText = `Hi , you have unread message in support service chat sent by  ${postUserFullName} - \n ${currentPost?.message}.`;
-      await this.sendMailOnPost(user, currentPost, channel, subject, userText, supportServiceConfig?.templateId || null, supportServiceConfig?.variables || null, supportServiceConfig?.email);
+      const userText = `Hi, you have unread message in support service chat sent by ${postUserFullName} - \n ${currentPost?.message}.`;
+      await this.sendMailOnPost(user, currentPost, channel, subject, userText, this.supportServiceenvConfig?.templateId || null, this.supportServiceenvConfig?.variables || null, this.supportServiceenvConfig?.email);
+    } catch (error) {
+      this.logger.error('Error sending service notification: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while sending service notification');
     }
   }
   async getServiceThreads(unit, value) {
-    const today = new Date();
-    const lastDay = sub(today, {
-      [unit]: value
-    });
-    const channels = await this.channelRepository.model.aggregate([{
-      $match: {
-        type: RoomType.Service
-      }
-    }, {
-      $project: {
-        _id: {
-          $toString: '$_id'
+    try {
+      const today = new Date();
+      const lastDay = sub(today, {
+        [unit]: value
+      });
+      const channels = await this.channelRepository.model.aggregate([{
+        $match: {
+          type: RoomType.Service
         }
-      }
-    }]);
-    const channelIds = channels?.map(c => c?._id?.toString())?.filter(id => id);
-    const postThreads = await this.postThreadRepository.model.find({
-      lastReplyAt: {
-        $gte: lastDay,
-        $lte: today
-      },
-      channel: {
-        $in: channelIds
-      }
-    });
-    return postThreads;
-  }
-  async getServicePosts(postThread) {
-    const post = await this.postRepository.model.findOne({
-      $or: [{
-        parentId: postThread?.post?.toString()
       }, {
-        _id: postThread?.post?.toString()
-      }]
-    }).lean().sort({
-      updatedAt: -1
-    });
-    return post;
+        $project: {
+          _id: {
+            $toString: '$_id'
+          }
+        }
+      }]);
+      const channelIds = channels?.map(c => c?._id?.toString())?.filter(id => id) || [];
+      const postThreads = await this.postThreadRepository.model.find({
+        lastReplyAt: {
+          $gte: lastDay,
+          $lte: today
+        },
+        channel: {
+          $in: channelIds
+        }
+      });
+      return postThreads || [];
+    } catch (error) {
+      this.logger.error('Error getting service threads: %o', error);
+      return [];
+    }
   }
-  async sendNotificationOfUnreadServiceMessages(unit, value) {
-    const threads = await this.getServiceThreads(unit, value);
-    const posts = await Promise.all(threads.map(this.getServicePosts.bind(this)));
-    if (posts && posts?.length > 0) await Promise.all(posts.map(this.sendServiceNotificationOnPost.bind(this)));
+  async getServicePosts(postThread) {
+    try {
+      const post = await this.postRepository.model.findOne({
+        $or: [{
+          parentId: postThread?.post?.toString()
+        }, {
+          _id: postThread?.post?.toString()
+        }]
+      }).lean().sort({
+        updatedAt: -1
+      });
+      return post || null;
+    } catch (error) {
+      this.logger.error('Error getting service posts: %o', error);
+      return null;
+    }
   }
 };
 MessengerNotificationService = __decorate([injectable(), __param(0, inject(SERVER_TYPES.ChannelRepository)), __param(1, inject(SERVER_TYPES.PostRepository)), __param(2, inject(SERVER_TYPES.PostThreadRepository)), __param(3, inject(SERVER_TYPES.CountryRepository)), __param(4, inject(CommonType.MOLECULER_BROKER)), __param(5, inject('Logger')), __metadata("design:paramtypes", [Object, Object, Object, Object, ServiceBroker, Object])], MessengerNotificationService);export{MessengerNotificationService};//# sourceMappingURL=messenger-notification-service.js.map