rez_core 2.2.263 → 2.3.2

package/src/module/integration/strategies/whatsapp/tubelight-whatsapp.strategy.ts

@@ -0,0 +1,419 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationResult,
+  IntegrationStrategy,
+} from '../integration.strategy';
+
+interface TubelightWhatsAppConfig {
+  userName: string;
+  password: string;
+  tenantId: string;
+  baseUrl?: string;
+  sourceNumber?: string;
+}
+
+interface TubelightMessage {
+  to: string;
+  message: string;
+  messageType?: string;
+  mediaUrl?: string;
+  caption?: string;
+  filename?: string;
+  templateId?: string;
+  templateParams?: any[];
+}
+
+interface TubelightApiResponse {
+  success: boolean;
+  messageId?: string;
+  id?: string;
+  status?: string;
+  message?: string;
+  error?: string;
+  details?: string;
+}
+
+@Injectable()
+export class TubelightWhatsAppStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(TubelightWhatsAppStrategy.name);
+  private readonly defaultBaseUrl =
+    'https://portal.tubelightcommunications.com/whatsapp/api/v1';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Tubelight WhatsApp configuration');
+      }
+
+      const tubelightConfig = config as TubelightWhatsAppConfig;
+      const token = await this.authenticate(tubelightConfig);
+
+      if (!token) {
+        throw new Error('Failed to authenticate with Tubelight');
+      }
+
+      const baseUrl = tubelightConfig.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/messages/send`;
+
+      const payload = this.prepareMessagePayload(to, message, config);
+
+      const response: AxiosResponse<TubelightApiResponse> = await axios.post(
+        url,
+        payload,
+        {
+          headers: {
+            'X-TENANT-ID': tubelightConfig.tenantId,
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
+          timeout: 30000,
+        },
+      );
+
+      if (
+        response.data?.success &&
+        (response.data?.messageId || response.data?.id)
+      ) {
+        const messageId = response.data.messageId || response.data.id;
+        this.logger.log(
+          `Tubelight WhatsApp message sent successfully to ${to}, messageId: ${messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: messageId,
+          provider: 'tubelight',
+          service: 'API',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(
+          response.data?.error ||
+            response.data?.message ||
+            'Invalid response from Tubelight API',
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send Tubelight WhatsApp message to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'tubelight',
+        service: 'API',
+        error: this.extractErrorMessage(error),
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private async authenticate(
+    config: TubelightWhatsAppConfig,
+  ): Promise<string | null> {
+    try {
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const authUrl = baseUrl.replace('/whatsapp/api/v1', '/auth/api/v1');
+
+      const response = await axios.post(
+        `${authUrl}/login`,
+        {
+          user_name: config.userName,
+          password: config.password,
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            'X-TENANT-ID': config.tenantId,
+          },
+        },
+      );
+
+      const data = response.data as {
+        bearer_token?: string;
+        access_token?: string;
+        token?: string;
+        success?: boolean;
+      };
+
+      if (data.success !== false) {
+        return data?.bearer_token || data?.access_token || data?.token || null;
+      }
+
+      return null;
+    } catch (error) {
+      this.logger.error(
+        'Failed to authenticate with Tubelight:',
+        error.response?.data || error.message,
+      );
+      return null;
+    }
+  }
+
+  private prepareMessagePayload(to: string, message: string, config: any): any {
+    const basePayload = {
+      to: this.formatPhoneNumber(to),
+      from: config.sourceNumber || config.from,
+    };
+
+    // Handle different message types based on config
+    if (config.messageType) {
+      switch (config.messageType) {
+        case 'template':
+          return {
+            ...basePayload,
+            messageType: 'TEMPLATE',
+            templateId: config.templateId,
+            templateParams: config.templateParams || [],
+            language: config.templateLanguage || 'en',
+          };
+
+        case 'image':
+          return {
+            ...basePayload,
+            messageType: 'IMAGE',
+            mediaUrl: config.mediaUrl,
+            caption: message || config.caption || '',
+          };
+
+        case 'document':
+          return {
+            ...basePayload,
+            messageType: 'DOCUMENT',
+            mediaUrl: config.mediaUrl,
+            filename: config.filename || 'document',
+            caption: message || config.caption || '',
+          };
+
+        case 'audio':
+          return {
+            ...basePayload,
+            messageType: 'AUDIO',
+            mediaUrl: config.mediaUrl,
+          };
+
+        case 'video':
+          return {
+            ...basePayload,
+            messageType: 'VIDEO',
+            mediaUrl: config.mediaUrl,
+            caption: message || config.caption || '',
+          };
+
+        case 'location':
+          return {
+            ...basePayload,
+            messageType: 'LOCATION',
+            latitude: config.latitude,
+            longitude: config.longitude,
+            name: config.locationName || '',
+            address: config.locationAddress || '',
+          };
+
+        case 'interactive':
+          return {
+            ...basePayload,
+            messageType: 'INTERACTIVE',
+            interactiveType: config.interactiveType || 'button',
+            text: message,
+            buttons: config.buttons || [],
+            sections: config.sections || [],
+            header: config.header,
+            footer: config.footer,
+          };
+
+        default:
+          // Fall back to text message
+          break;
+      }
+    }
+
+    // Default text message
+    return {
+      ...basePayload,
+      messageType: 'TEXT',
+      text: message,
+    };
+  }
+
+  private formatPhoneNumber(phoneNumber: string): string {
+    // Remove any non-digit characters except +
+    let formatted = phoneNumber.replace(/[^\d+]/g, '');
+
+    // If it doesn't start with +, assume it needs country code
+    if (!formatted.startsWith('+')) {
+      formatted = `+${formatted}`;
+    }
+
+    return formatted;
+  }
+
+  private extractErrorMessage(error: any): string {
+    if (error.response?.data?.error) {
+      return error.response.data.error;
+    }
+
+    if (error.response?.data?.message) {
+      return error.response.data.message;
+    }
+
+    if (error.response?.data?.details) {
+      return error.response.data.details;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return 'Unknown Tubelight API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (!config.userName || !config.password || !config.tenantId) {
+      return false;
+    }
+
+    // Validate message type specific requirements
+    if (config.messageType) {
+      switch (config.messageType) {
+        case 'template':
+          if (!config.templateId) {
+            return false;
+          }
+          break;
+
+        case 'image':
+        case 'document':
+        case 'audio':
+        case 'video':
+          if (!config.mediaUrl) {
+            return false;
+          }
+          break;
+
+        case 'location':
+          if (
+            typeof config.latitude !== 'number' ||
+            typeof config.longitude !== 'number'
+          ) {
+            return false;
+          }
+          break;
+
+        case 'interactive':
+          if (
+            !config.buttons &&
+            !config.sections &&
+            (!config.interactiveType ||
+              !['button', 'list'].includes(config.interactiveType))
+          ) {
+            return false;
+          }
+          break;
+      }
+    }
+
+    return true;
+  }
+
+  async getAccountInfo(config: TubelightWhatsAppConfig): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/account/info`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Tubelight account info',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get account info: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async getTemplates(config: TubelightWhatsAppConfig): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/templates`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Tubelight templates',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get templates: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async getMessageStatus(
+    config: TubelightWhatsAppConfig,
+    messageId: string,
+  ): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/messages/${messageId}/status`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get message status',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get message status: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+}

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -22,7 +22,6 @@ export class LayoutPreferenceService extends EntityServiceImpl {
       throw new Error('User ID is required to create layout preference.');
     }
 
-    console.log(mapped_entity_type, loggedInUser, userId);
     const existingLayoutPreference =
       await this.layoutPreferenceRepository.findByEntityUserId(
         mapped_entity_type,
@@ -32,7 +31,6 @@ export class LayoutPreferenceService extends EntityServiceImpl {
         type,
       );
 
-    console.log(existingLayoutPreference, 'existingLayoutPreference');
     if (existingLayoutPreference) {
       return await super.updateEntity(
         { ...entityData, id: existingLayoutPreference.id },

package/src/module/listmaster/service/list-master.service.ts

@@ -98,16 +98,7 @@ export class ListMasterService {
     inactiveIdsArray?: number[],
     loggedInUser?: UserData,
   ) {
-    console.log(
-      sourceList,
-      'sourceList',
-      params,
-      'params',
-      inactiveIdsArray,
-      'inactiveIdsArray',
-      loggedInUser,
-      'loggedInUser',
-    );
+
     let result: { label: string; value: number }[] = [];
     if (!sourceList) return result;
 

package/src/module/master/service/master.service.ts

@@ -229,12 +229,10 @@ export class MasterService {
         loggedInUser,
       );
 
-    console.log(attributes, 'attributes');
     const uniqueFields = attributes
       .filter((attr) => attr.is_unique)
       .map((attr) => attr.attribute_key);
 
-    console.log(uniqueFields, 'uniqueFields');
 
     if (uniqueFields.length === 0) {
       throw new Error(`No unique fields found for entityType: ${entityType}`);

package/src/module/meta/repository/entity-table.repository.ts

@@ -36,7 +36,6 @@ export class EntityTableRepository {
     displayType: string,
     organization_id: number,
   ) {
-    console.log(entityType, listType, displayType, organization_id);
 
     const whereCondition: any = {
       mapped_entity_type: entityType,

package/src/module/meta/service/entity-dynamic.service.ts

@@ -523,11 +523,7 @@ export class EntityDynamicService {
         row[attr.attribute_key] !== undefined
       ) {
         // fetch media data
-        console.log(
-          'Fetching media for',
-          attr.attribute_key,
-          row[attr.attribute_key],
-        );
+
 
         row[attr.attribute_key] =
           row[attr.attribute_key] != null

package/src/module/meta/service/entity-service-impl.service.ts

@@ -108,10 +108,6 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       [STATUS_ACTIVE, loggedInUser?.organization_id],
     );
 
-    console.log('Status List:', statusList); // Debug log
-    console.log(
-      `status_code,${STATUS_ACTIVE},statusList, ${loggedInUser?.organization_id}`,
-    ); // Debug log
 
     entityData.created_date = new Date();
     if (loggedInUser) {

package/src/module/meta/service/entity-table.service.ts

@@ -79,14 +79,12 @@ export class EntityTableService {
     displayType: string,
     loggedInUser: any,
   ) {
-    console.log(entityType, listType, displayType, loggedInUser);
     const entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
       entityType,
       listType,
       displayType,
       loggedInUser?.organization_id,
     );
-    console.log(entityTable, 'entityTable');
     const entityTableDto = entityTable as EntityTableDto;
     if (entityTable) {
       entityTableDto.column_list =

package/src/module/meta/service/field-group.service.ts

@@ -53,7 +53,6 @@ export class FieldGroupService extends EntityServiceImpl {
 
     if (layoutJson?.form?.children && Array.isArray(layoutJson.form.children)) {
       const firstChild = layoutJson.form.children[0];
-      console.log('First Child:', firstChild);
 
       if (firstChild.type === 'wizard' && Array.isArray(firstChild.steps)) {
         console.log('Wizard Steps:', firstChild.steps);

package/src/module/module/service/module-access.service.ts

@@ -149,14 +149,6 @@ export class ModuleAccessService {
     level_id: number;
     organization_id: number;
   }) {
-    console.log(
-      'step 1',
-      userId,
-      appcode,
-      level_type,
-      level_id,
-      organization_id,
-    );
 
     // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
@@ -166,21 +158,18 @@ export class ModuleAccessService {
       level_id,
     );
 
-    console.log(roleCodes, 'roleCodes');
 
     if (!roleCodes || roleCodes.length === 0) {
       return [];
     }
 
     const roleIds = roleCodes.map(Number);
-    console.log('step 2', roleIds);
     // Step 2: Get full permissions
     const allPermissions =
       await this.moduleAccessRepository.getModuleAccessByRoles(
         roleIds,
         appcode,
       );
-    console.log('step 2', allPermissions);
 
     // Step 3: If level_type is SCH, check school status using raw query
     if (level_type === 'SCH') {
@@ -190,7 +179,6 @@ export class ModuleAccessService {
       );
 
       const school = result?.[0];
-      console.log('step 3', school);
 
       const resolveStatus = await this.listMasterService.getResolvedListCode(
         STATUS_INACTIVE,
@@ -202,7 +190,6 @@ export class ModuleAccessService {
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }
     }
-    console.log('step 4', allPermissions);
     // Step 4: Return all permissions normally
     return allPermissions;
   }

package/src/module/notification/controller/notification.controller.ts

@@ -23,12 +23,19 @@ export class NotificationsController {
 
   @Post('send')
   async sendNotification(
-    @Body() body: { token: string; title: string; message: string },
+    @Body()
+    body: {
+      token: string;
+      title: string;
+      message: string;
+      data?: Record<string, any>;
+    },
   ) {
     return this.notificationsService.sendToDevice(
       body.token,
       body.title,
       body.message,
+      body.data,
     );
   }
 

package/src/module/notification/service/email.service.ts

@@ -58,7 +58,6 @@ export class EmailService {
         // Optionally: push to a retry queue, Sentry, DB log, etc.
       });
 
-    console.log(result); // Return immediately (parent doesn’t block)
     return;
   }
 

package/src/module/notification/service/notification.service.ts

@@ -20,13 +20,28 @@ export class NotificationsService {
     return { success: true, token };
   }
 
-  async sendToDevice(token: string, title: string, body: string) {
-    const message = {
+  async sendToDevice(
+    token: string,
+    title: string,
+    body: string,
+    data?: Record<string, any>,
+  ) {
+    const message: admin.messaging.Message = {
       token,
-      notification: { title, body },
+      notification: { title, body }, // system notification
+      data: data
+        ? Object.fromEntries(
+            Object.entries(data).map(([k, v]) => [k, v.toString()]),
+          )
+        : undefined, // FCM requires all values to be strings
     };
 
-    return this.firebaseAdmin.messaging().send(message);
+    try {
+      return await this.firebaseAdmin.messaging().send(message);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
   }
 
   // Helper: send to a registered user by userId

package/src/module/user/service/login.service.ts

@@ -43,7 +43,6 @@ export class LoginService {
 
     let organization;
 
-    console.log('data', data);
 
     // 🔹 Step 2: Find the user by email + organization check
     const user = await this.userService.findByEmailId(email);

package/src/module/workflow/repository/stage.repository.ts

@@ -107,8 +107,7 @@ export class StageRepository {
     //   [stageGroup.workflow_id, organization_id],
     // );
 
-    console.log(rows, '-----------LEFT JOIN----------');
-    // console.log(rows2, '-----------INNER JOIN----------');
+
 
     if (!rows || rows.length === 0) {
       return [];

package/src/module/workflow/service/action.service.ts

@@ -122,7 +122,6 @@ export class ActionService extends EntityServiceImpl {
     entityData: BaseEntity,
     loggedInUser: UserData,
   ): Promise<any> {
-    console.log('entityData', entityData);
 
     // Extract template from entityData, keep the rest for ActionEntity
     const { template, stage_id, form, ...actionData } =

package/src/module/workflow/service/comm-template.service.ts

@@ -40,7 +40,6 @@ export class CommTemplateService extends EntityServiceImpl {
   async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
     const { attachments, ...templateData } = entityData;
 
-    console.log('update for template hit', entityData, loggedInUser);
 
     if (
       loggedInUser.level_type === 'SCH' &&