rez_core 2.2.224 → 2.2.225

package/docs/modules/communication.md

@@ -0,0 +1,177 @@
+# Communication Module Documentation
+
+## Database Schema
+
+### Tables: cr_communication_config & cr_communication_hub
+```sql
+-- Configuration storage
+CREATE TABLE cr_communication_config (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    config_json JSON NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);
+
+-- Hub mapping level->provider
+CREATE TABLE cr_communication_hub (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    level_id INT NOT NULL,
+    level_type VARCHAR(100) NOT NULL, -- 'organization', 'department', 'user', 'project'
+    status TINYINT DEFAULT 1,
+    config_id INT NOT NULL,
+    communication_config_type ENUM('WA','SMS','EMAIL','TELEPHONE') NOT NULL,
+    service VARCHAR(100) NOT NULL,  -- API, THIRD_PARTY, SMTP
+    provider VARCHAR(100) NOT NULL, -- gmail, outlook, twilio, whatsapp, etc.
+    priority INT DEFAULT 1,
+    is_default BOOLEAN DEFAULT FALSE,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    INDEX idx_level_status (level_id, level_type, status),
+    INDEX idx_config_type (communication_config_type)
+);
+```
+
+## Architecture: Hierarchical Factory Pattern
+
+### Strategy Interface
+```ts
+export interface CommunicationStrategy {
+  sendMessage(to: string, message: string, config: any): Promise<any>;
+}
+```
+
+### Factory Structure (Mode → Service → Provider)
+- **EMAIL**: API (gmail, outlook, aws-ses) | SMTP (gmail, outlook, sendgrid, generic)
+- **SMS**: THIRD_PARTY (twilio, knowlarity)
+- **WA**: API (whatsapp)
+- **TELEPHONE**: THIRD_PARTY (knowlarity)
+
+### Main Factory
+```ts
+@Injectable()
+export class CommunicationFactory {
+  create(mode: string, service: string, provider: string): CommunicationStrategy {
+    // Returns appropriate strategy instance
+  }
+  
+  getAllSupportedCombinations(): Array<{mode, service, provider}> {}
+  getSupportedCombinationsForMode(mode: string): Array<{service, provider}> {}
+  validateCombination(mode: string, service: string, provider: string): boolean {}
+}
+```
+
+### Service Layer
+```ts
+@Injectable()
+export class CommunicationService {
+  // Main send with fallback
+  async send(orgId: number, to: string, message: string, type?: string, options: any = {}) {}
+  
+  // Type-specific methods
+  async sendEmail(orgId: number, to: string, subject: string, body: string, attachments?: any[]) {}
+  async sendSMS(orgId: number, to: string, message: string) {}
+  async sendWhatsApp(orgId: number, to: string, message: string, mediaUrl?: string) {}
+  
+  // Bulk & template support
+  async sendBulk(orgId: number, recipients: string[], message: string, type?: string) {}
+  async sendWithTemplate(orgId: number, to: string, templateId: string, variables: any) {}
+  
+  // Configuration management
+  async createConfiguration(orgId: number, configData: any) {}
+  async updateConfiguration(hubId: number, configData: any) {}
+  async setDefaultProvider(hubId: number) {}
+}
+```
+
+## Provider Configuration Examples
+
+### Gmail API
+```json
+{
+  "type": "EMAIL", "service": "API", "provider": "gmail",
+  "config": {
+    "clientId": "your-client-id.apps.googleusercontent.com",
+    "clientSecret": "your-client-secret", 
+    "refreshToken": "your-refresh-token",
+    "accessToken": "your-access-token"
+  }
+}
+```
+
+### Gmail SMTP
+```json
+{
+  "type": "EMAIL", "service": "SMTP", "provider": "gmail",
+  "config": {
+    "email": "your-email@gmail.com",
+    "password": "your-app-password",
+    "subject": "Default Subject"
+  }
+}
+```
+
+### Twilio SMS
+```json
+{
+  "type": "SMS", "service": "THIRD_PARTY", "provider": "twilio",
+  "config": {
+    "accountSid": "your-twilio-account-sid",
+    "authToken": "your-twilio-auth-token", 
+    "fromNumber": "+1234567890"
+  }
+}
+```
+
+### WhatsApp Cloud API
+```json
+{
+  "type": "WA", "service": "API", "provider": "whatsapp",
+  "config": {
+    "accessToken": "your-whatsapp-access-token",
+    "phoneNumberId": "your-phone-number-id",
+    "apiVersion": "v17.0"
+  }
+}
+```
+
+### Knowlarity Voice
+```json
+{
+  "type": "TELEPHONE", "service": "THIRD_PARTY", "provider": "knowlarity",
+  "config": {
+    "apiKey": "your-knowlarity-api-key",
+    "apiSecret": "your-knowlarity-api-secret",
+    "callerNumber": "your-knowlarity-number",
+    "callType": "voice",
+    "language": "en"
+  }
+}
+```
+
+## API Endpoints
+
+```
+POST /communication/send
+POST /communication/config
+GET /communication/level/:id/:type/configs
+POST /communication/gmail/oauth/init
+POST /communication/oauth/callback/gmail
+```
+
+## Module Structure
+```
+src/module/communication/
+├── controller/communication.controller.ts
+├── entity/communication-{config,hub,log}.entity.ts  
+├── service/communication.service.ts
+├── factories/communication.factory.ts
+├── strategies/gmail.strategy.ts (and others)
+└── communication.module.ts
+```
+
+## Level Hierarchy (fallback order)
+1. **user** (highest priority)
+2. **team** 
+3. **project**
+4. **department**
+5. **organization** (lowest priority)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.2.224",
+  "version": "2.2.225",
   "description": "",
   "author": "",
   "private": false,

package/src/app.module.ts

@@ -18,6 +18,7 @@ import { IcsMeetingModule } from './module/ics/ics.module';
 import { DashboardModule } from './module/dashboard/dashboard.module';
 import { CommunicationModule } from './module/communication/communication.module';
 import { ScheduleModule } from '@nestjs/schedule';
+import { AuthModule } from './module/auth/auth.module';
 
 @Module({
   imports: [
@@ -39,6 +40,7 @@ import { ScheduleModule } from '@nestjs/schedule';
     IcsMeetingModule,
     DashboardModule,
     CommunicationModule,
+    AuthModule,
     ScheduleModule.forRoot(),
   ],
 })

package/src/module/auth/auth.module.ts

@@ -10,6 +10,9 @@ import { PassportModule } from '@nestjs/passport';
 import { UserSession } from '../user/entity/user-session.entity';
 import { GoogleStrategy } from './strategies/google.strategy';
 import { RolesGuard } from './guards/role.guard';
+import { AuthService } from './services/auth.service';
+import { AuthController } from './controller/auth.controller';
+import { UserModule } from '../user/user.module';
 
 @Module({
   imports: [
@@ -30,16 +33,17 @@ import { RolesGuard } from './guards/role.guard';
         };
       },
     }),
-
     TypeOrmModule.forFeature([UserSession]),
   ],
+  controllers: [AuthController],
   providers: [
     JwtAuthService,
     JwtStrategy,
     JwtAuthGuard,
     GoogleStrategy,
     RolesGuard,
+    AuthService,
   ],
-  exports: [JwtAuthService, JwtAuthGuard, RolesGuard],
+  exports: [JwtAuthService, JwtAuthGuard, RolesGuard, AuthService],
 })
 export class AuthModule {}

package/src/module/auth/controller/auth.controller.ts

@@ -0,0 +1,28 @@
+import { Body, Controller, Post, Req, UseGuards } from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { AuthService } from '../services/auth.service';
+import { UAParser } from 'ua-parser-js';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('fcmtoken')
+  @UseGuards(JwtAuthGuard)
+  async getDashboard(@Req() req: any, @Body('fcmtoken') fcmtoken: string) {
+    const loggedInUser = req.user.userData;
+
+    const ip =
+      (req.headers['x-forwarded-for'] as string)?.split(',')[0].trim() ||
+      req.socket.remoteAddress ||
+      req.ip ||
+      '';
+
+    const userAgent = req.headers['user-agent'] || '';
+    const parser = new UAParser(userAgent);
+    const browser = parser.getBrowser().name || 'Unknown';
+    const os = parser.getOS().name || 'Unknown';
+
+    return this.authService.fcmtoken(fcmtoken, loggedInUser, ip, browser, os);
+  }
+}

package/src/module/auth/services/auth.service.ts

@@ -1,29 +1,50 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { UserService } from '../../user/service/user.service';
 import { JwtService } from '@nestjs/jwt';
 import { UserData } from '../../user/entity/user.entity';
+import { DataSource } from 'typeorm';
 
 @Injectable()
 export class AuthService {
   constructor(
-    private userService: UserService,
     private jwtService: JwtService,
+    private dataSource: DataSource,
   ) {}
 
-  async validateUser(email: string, password: string): Promise<UserData> {
-    const user = await this.userService.findByEmailId(email);
-    if (!user) {
-      throw new BadRequestException('User not found');
-    }
-    const isMatch: boolean = password === user.password;
-    if (!isMatch) {
-      throw new BadRequestException('Password does not match');
-    }
-    return user;
-  }
+  // async validateUser(email: string, password: string): Promise<UserData> {
+  //   const user = await this.userService.findByEmailId(email);
+  //   if (!user) {
+  //     throw new BadRequestException('User not found');
+  //   }
+  //   const isMatch: boolean = password === user.password;
+  //   if (!isMatch) {
+  //     throw new BadRequestException('Password does not match');
+  //   }
+  //   return user;
+  // }
 
   async login(user: UserData) {
     const payload = { email: user.email_id, id: user.id };
     return { access_token: this.jwtService.sign(payload) };
   }
+
+  async fcmtoken(
+    fcmtoken: string,
+    loggedInUser: any,
+    ip: string,
+    browser: string,
+    os: string,
+  ) {
+    const { id: userId, organization_id } = loggedInUser;
+
+    // Update the cr_user table
+    await this.dataSource.query(
+      `UPDATE cr_user
+       SET fcm_token = ?, ip = ?, browser = ?, os = ?
+       WHERE id = ? AND organization_id = ?`,
+      [fcmtoken, ip, browser, os, userId, organization_id],
+    );
+
+    return { message: 'FCM token updated successfully' };
+  }
 }

package/src/module/communication/communication.module.ts

@@ -50,7 +50,12 @@ import { WebhookController } from './controller/webhook.controller';
     TypeOrmModule.forFeature([CommunicationConfig, CommunicationHub]),
     IcsMeetingModule,
   ],
-  controllers: [CommunicationController, GoogleController, WrapperController, WebhookController],
+  controllers: [
+    CommunicationController,
+    GoogleController,
+    WrapperController,
+    WebhookController,
+  ],
   providers: [
     // Main Services
     CommunicationService,

package/src/module/rule_engine/entity/rule-engine.entity.ts

@@ -0,0 +1,32 @@
+import { ACTION_CATEGORY } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_rule_' })
+export class ActionCategory extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ACTION_CATEGORY;
+  }
+
+  @Column({ type: 'varchar', nullable: true })
+  logo: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  modalName: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  reason_code: string;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_template: boolean;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_form: boolean;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_assignment: boolean;
+}