rez_core 2.2.155 → 2.2.157

package/src/module/communication/strategies/knowlarity.strategy.ts

@@ -0,0 +1,124 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class KnowlarityStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { 
+        apiKey,
+        apiSecret, 
+        callerNumber,
+        baseUrl = 'https://kpi.knowlarity.com/Basic',
+        callType = 'voice',
+        language = 'en'
+      } = config;
+
+      if (callType === 'voice') {
+        const callData = {
+          k_number: callerNumber,
+          agent_number: to,
+          caller_id: callerNumber,
+          voice_message: config.voiceMessage || message,
+          language: language,
+          api_key: apiKey,
+          api_secret: apiSecret,
+          format: 'json'
+        };
+
+        const response = await axios.post(`${baseUrl}/start_call.php`, callData, {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          transformRequest: [(data) => {
+            return Object.keys(data)
+              .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
+              .join('&');
+          }]
+        });
+
+        return {
+          success: response.data.status === 'success',
+          provider: 'knowlarity',
+          service: 'THIRD_PARTY',
+          messageId: response.data.call_id,
+          timestamp: new Date(),
+        };
+      }
+
+      if (callType === 'sms') {
+        const smsData = {
+          k_number: callerNumber,
+          agent_number: to,
+          sms_text: message,
+          api_key: apiKey,
+          api_secret: apiSecret,
+          format: 'json'
+        };
+
+        const response = await axios.post(`${baseUrl}/send_sms.php`, smsData, {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          transformRequest: [(data) => {
+            return Object.keys(data)
+              .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
+              .join('&');
+          }]
+        });
+
+        return {
+          success: response.data.status === 'success',
+          provider: 'knowlarity',
+          service: 'THIRD_PARTY',
+          messageId: response.data.message_id,
+          timestamp: new Date(),
+        };
+      }
+
+      throw new Error('Invalid call type. Must be "voice" or "sms"');
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.apiKey &&
+      config.apiSecret &&
+      config.callerNumber &&
+      ['voice', 'sms'].includes(config.callType)
+    );
+  }
+
+  async getCallStatus(callId: string, config: any): Promise<any> {
+    const { apiKey, apiSecret, baseUrl = 'https://kpi.knowlarity.com/Basic' } = config;
+
+    const statusData = {
+      call_id: callId,
+      api_key: apiKey,
+      api_secret: apiSecret,
+      format: 'json'
+    };
+
+    const response = await axios.post(`${baseUrl}/call_details.php`, statusData, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      transformRequest: [(data) => {
+        return Object.keys(data)
+          .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
+          .join('&');
+      }]
+    });
+
+    return response.data;
+  }
+}

package/src/module/communication/strategies/outlook-smtp.strategy.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import * as nodemailer from 'nodemailer';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class OutlookSMTPStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { 
+        email, 
+        password, 
+        subject = 'Notification',
+        html,
+        attachments,
+        cc,
+        bcc 
+      } = config;
+
+      const transporter = nodemailer.createTransport({
+        host: 'smtp-mail.outlook.com',
+        port: 587,
+        secure: false,
+        auth: {
+          user: email,
+          pass: password,
+        },
+        tls: {
+          ciphers: 'SSLv3',
+        },
+      });
+
+      const mailOptions = {
+        from: email,
+        to: Array.isArray(to) ? to.join(',') : to,
+        cc: cc ? (Array.isArray(cc) ? cc.join(',') : cc) : undefined,
+        bcc: bcc ? (Array.isArray(bcc) ? bcc.join(',') : bcc) : undefined,
+        subject,
+        text: message,
+        html: html || message,
+        attachments: attachments || [],
+      };
+
+      const result = await transporter.sendMail(mailOptions);
+
+      return {
+        success: true,
+        provider: 'outlook',
+        service: 'SMTP',
+        messageId: result.messageId,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'outlook',
+        service: 'SMTP',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.email &&
+      config.password
+    );
+  }
+}

package/src/module/communication/strategies/outlook.strategy.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@nestjs/common';
+import { Client } from '@microsoft/microsoft-graph-client';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class OutlookStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accessToken } = config;
+      
+      const graphClient = Client.init({
+        authProvider: {
+          getAccessToken: async () => accessToken,
+        } as any,
+      });
+
+      const subject = config.subject || 'Notification';
+      const mail = {
+        message: {
+          subject,
+          body: {
+            contentType: config.html ? 'HTML' : 'Text',
+            content: config.html || message,
+          },
+          toRecipients: [
+            {
+              emailAddress: {
+                address: to,
+              },
+            },
+          ],
+        },
+      };
+
+      await graphClient.api('/me/sendMail').post(mail);
+
+      return {
+        success: true,
+        provider: 'outlook',
+        service: 'API',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'outlook',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(config.accessToken);
+  }
+}

package/src/module/communication/strategies/sms/knowlarity.strategy.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class KnowlarityStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Knowlarity configuration');
+      }
+
+      // Knowlarity API implementation would go here
+      // This is a placeholder for actual Knowlarity integration
+      console.log('Sending SMS via Knowlarity to:', to);
+
+      return {
+        success: true,
+        messageId: `knowlarity-${Date.now()}`,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return config && config.apiKey && config.senderId;
+  }
+}

package/src/module/communication/strategies/sms/twilio.strategy.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class TwilioStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Twilio configuration');
+      }
+
+      // Twilio SDK implementation would go here
+      // This is a placeholder for actual Twilio integration
+      console.log('Sending SMS via Twilio to:', to);
+
+      return {
+        success: true,
+        messageId: `twilio-${Date.now()}`,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return config && config.accountSid && config.authToken && config.fromNumber;
+  }
+}

package/src/module/communication/strategies/sms.strategy.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { Twilio } from 'twilio';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class SmsStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accountSid, authToken, fromNumber } = config;
+      
+      const client = new Twilio(accountSid, authToken);
+      
+      const result = await client.messages.create({
+        body: message,
+        from: fromNumber,
+        to: to,
+      });
+
+      return {
+        success: true,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        messageId: result.sid,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.accountSid &&
+      config.authToken &&
+      config.fromNumber
+    );
+  }
+}

package/src/module/communication/strategies/telephone/knowlarity-voice.strategy.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class KnowlarityVoiceStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Knowlarity Voice configuration');
+      }
+
+      // Knowlarity Voice API implementation would go here
+      // This is a placeholder for actual voice call integration
+      console.log('Initiating voice call via Knowlarity to:', to);
+
+      return {
+        success: true,
+        messageId: `knowlarity-voice-${Date.now()}`,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return config && config.apiKey && config.callerId && config.voiceUrl;
+  }
+}

package/src/module/communication/strategies/whatsapp/whatsapp-cloud.strategy.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class WhatsAppCloudStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid WhatsApp Cloud API configuration');
+      }
+
+      // WhatsApp Cloud API implementation would go here
+      // This is a placeholder for actual WhatsApp integration
+      console.log('Sending WhatsApp message via Cloud API to:', to);
+
+      return {
+        success: true,
+        messageId: `whatsapp-${Date.now()}`,
+        provider: 'whatsapp',
+        service: 'API',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'whatsapp',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return (
+      config &&
+      config.accessToken &&
+      config.phoneNumberId &&
+      config.businessAccountId
+    );
+  }
+}

package/src/module/communication/strategies/whatsapp.strategy.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class WhatsAppStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accessToken, phoneNumberId, apiVersion = 'v17.0' } = config;
+      
+      const url = `https://graph.facebook.com/${apiVersion}/${phoneNumberId}/messages`;
+      
+      const payload = {
+        messaging_product: 'whatsapp',
+        to: to,
+        type: 'text',
+        text: {
+          body: message,
+        },
+      };
+
+      const response = await axios.post(url, payload, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      return {
+        success: true,
+        provider: 'whatsapp',
+        service: 'API',
+        messageId: response.data.messages[0].id,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'whatsapp',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.accessToken &&
+      config.phoneNumberId
+    );
+  }
+}

package/src/module/enterprise/entity/organization.entity.ts

@@ -86,4 +86,7 @@ export class OrganizationData {
 
   @Column({ name: 'wbs_code', nullable: true })
   wbs_code: string;
+
+  @Column({ name: 'subdomain', nullable: true })
+  subdomain: string;
 }

package/src/module/enterprise/repository/organization.repository.ts

@@ -15,4 +15,10 @@ export class OrganizationRepository {
       where: { id },
     });
   }
+
+  async findOrganizationBySubdomain(subdomain: string): Promise<OrganizationData | null> {
+    return await this.organizationRepository.findOne({
+      where: { subdomain },
+    });
+  }
 }

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

@@ -21,51 +21,56 @@ export class MasterService {
     protected readonly entityValidationService: EntityValidationService,
   ) {}
 
-  private readonly metaSheets = [
-    'cr_entity_master',
-    'cr_attribute_master',
-    'cr_list_master',
-    'cr_list_master_items',
-    'cr_entity_table',
-    'cr_entity_table_column',
-    'cr_view_master',
-  ];
+  // private readonly metaSheets = [
+  //   'cr_entity_master',
+  //   'cr_attribute_master',
+  //   'cr_list_master',
+  //   'cr_list_master_items',
+  //   'cr_entity_table',
+  //   'cr_entity_table_column',
+  //   'cr_view_master',
+  // ];
   private readonly sequence = [
     {
       table: 'cr_entity_master',
-      unique_fields: ['mapped_entity_type'],
+      unique_fields: ['id', 'organization_id'],
     },
     {
       table: 'cr_attribute_master',
-      unique_fields: ['mapped_entity_type', 'attribute_key'],
+      unique_fields: ['mapped_entity_type', 'attribute_key', 'organization_id'],
     },
     {
       table: 'cr_list_master',
-      unique_fields: ['type'],
+      unique_fields: ['type', 'organization_id'],
     },
     {
       table: 'cr_list_master_items',
-      unique_fields: ['listtype', 'code'],
+      unique_fields: ['listtype', 'code', 'organization_id'],
     },
     {
       table: 'cr_entity_table',
-      unique_fields: ['list_type', 'mapped_entity_type'],
+      unique_fields: ['list_type', 'mapped_entity_type', 'organization_id'],
     },
     {
       table: 'cr_entity_table_column',
-      unique_fields: ['parent_id', 'parent_type', 'attribute_key'],
+      unique_fields: [
+        'parent_id',
+        'parent_type',
+        'attribute_key',
+        'organization_id',
+      ],
     },
     {
       table: 'cr_view_master',
-      unique_fields: ['mapped_entity_type'],
+      unique_fields: ['mapped_entity_type', 'organization_id'],
     },
     {
       table: 'cr_user',
-      unique_fields: ['email_id', 'mobile', 'code'],
+      unique_fields: ['organization_id'],
     },
     {
       table: 'cr_header_items',
-      unique_fields: ['code', 'section_id'],
+      unique_fields: ['code', 'section_id', 'organization_id'],
     },
     {
       table: 'cr_module_access',
@@ -73,27 +78,27 @@ export class MasterService {
     },
     {
       table: 'cr_module_action',
-      unique_fields: ['module_code', 'action_type'],
+      unique_fields: ['module_code', 'action_type', 'organization_id'],
     },
     {
       table: 'cr_menu',
-      unique_fields: ['module_code'],
+      unique_fields: ['module_code', 'organization_id'],
     },
     {
       table: 'cr_module',
-      unique_fields: ['module_code'],
+      unique_fields: ['module_code', 'organization_id'],
     },
     {
       table: 'cr_role',
-      unique_fields: ['code'],
+      unique_fields: ['code', 'organization_id'],
     },
     {
       table: 'cr_header_sections',
-      unique_fields: ['section_name'],
+      unique_fields: ['section_name', 'organization_id'],
     },
     {
       table: 'cr_user_role_mapping',
-      unique_fields: ['user_id', 'role_id'],
+      unique_fields: ['user_id', 'role_id', 'organization_id'],
     },
     {
       table: 'cr_organization',

package/src/module/meta/controller/entity-master.controller.ts

@@ -0,0 +1,28 @@
+import {
+  Controller,
+  Post,
+  Body,
+  Param,
+  Req,
+  UseGuards,
+  Get,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { EntityMasterService } from '../service/entity-master.service';
+import { HttpCode } from '@nestjs/common';
+import { HttpStatus } from '@nestjs/common';
+
+@Controller('entity-master')
+@UseGuards(JwtAuthGuard)
+export class EntityMasterController {
+  constructor(private readonly entityMasterService: EntityMasterService) {}
+
+  @Get('getById/:id')
+  @HttpCode(HttpStatus.OK)
+  async getEntityById(
+    @Param('id') id: number,
+    @Req() req: Request & { user: any },
+  ) {
+    return await this.entityMasterService.getEntityById(id);
+  }
+}