rez_core 2.2.134 → 2.2.136

package/package.json

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

package/src/module/auth/strategies/google.strategy.ts

@@ -5,22 +5,14 @@ import { Strategy, VerifyCallback } from 'passport-google-oauth20';
 
 @Injectable()
 export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
-  constructor(configService: ConfigService) {
-    const clientID = configService.get<string>('CLIENT_ID');
-    const clientSecret = configService.get<string>('CLIENT_SECRET');
-    const callbackURL = configService.get<string>('CALLBACK_URL');
-
-    console.log('Google OAuth config', {
-      clientID,
-      clientSecret,
-      callbackURL,
-    });
-
+  constructor(private configService: ConfigService) {
     super({
-      clientID,
-      clientSecret,
-      callbackURL,
-      scope: ['email', 'profile'],
+      clientID: configService.get('CLIENT_ID'),
+      clientSecret: configService.get('CLIENT_SECRET'),
+      callbackURL: configService.get('CALLBACK_URL'),
+      scope: ['openid', 'email', 'profile'],
+      accessType: 'offline',
+      prompt: 'consent',
     });
   }
 
@@ -30,8 +22,20 @@ export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
     profile: any,
     done: VerifyCallback,
   ) {
-    const { emails, name } = profile;
-    const email = emails?.[0]?.value;
-    return done(null, { email, name });
+    const email = profile.emails?.[0]?.value ?? null;
+    const name = {
+      givenName: profile.name?.givenName ?? '',
+      familyName: profile.name?.familyName ?? '',
+      displayName: profile.displayName ?? '',
+    };
+
+    // attach what you need; do not persist here if you follow clean patterns
+    return done(null, {
+      email,
+      name,
+      accessToken,
+      refreshToken,
+      provider: 'google',
+    });
   }
 }

package/src/module/dashboard/controller/dashboard.controller.ts

@@ -0,0 +1,25 @@
+import {
+  Controller,
+  Get,
+  Param,
+  ParseIntPipe,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { DashboardService } from '../service/dashboard.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('dashboard')
+export class DashboardController {
+  constructor(private readonly dashboardService: DashboardService) {}
+
+  @Get('page-data/:pageId')
+  @UseGuards(JwtAuthGuard)
+  async getDashboard(
+    @Param('pageId', ParseIntPipe) pageId: number,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user.userData;
+    return this.dashboardService.getDashboardPage(pageId, loggedInUser);
+  }
+}

package/src/module/dashboard/dashboard.module.ts

@@ -3,13 +3,17 @@ import { EntityModule } from '../meta/entity.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { WidgetMaster } from './entity/widget_master.entity';
 import { DashboardPageData } from './entity/dashboard_page_data.entity';
+import { DashboardController } from './controller/dashboard.controller';
+import { DashboardService } from './service/dashboard.service';
+import { DashboardRepository } from './repository/dashboard.repository';
 
 @Module({
   imports: [
     EntityModule,
     TypeOrmModule.forFeature([WidgetMaster, DashboardPageData]),
   ],
-  controllers: [],
-  providers: [],
+  controllers: [DashboardController],
+  providers: [DashboardService, DashboardRepository],
+  exports: [DashboardService],
 })
 export class DashboardModule {}

package/src/module/dashboard/entity/dashboard_page_data.entity.ts

@@ -3,15 +3,25 @@ import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'cr_dashboard_page_data' })
 export class DashboardPageData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'DASH';
+  }
   @Column({ type: 'int', nullable: true })
   page_sequence: number;
 
   @Column({ type: 'varchar', nullable: true })
   applicable_type: string;
 
+  @Column({ type: 'varchar', nullable: true })
+  applicable_id: string;
+
   @Column({ type: 'boolean', nullable: true })
   is_hidden: boolean;
 
   @Column({ type: 'json', nullable: true })
   layout_json: any;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
 }

package/src/module/dashboard/entity/widget_master.entity.ts

@@ -3,6 +3,10 @@ import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'cr_widget_master' })
 export class WidgetMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'WIDG';
+  }
   @Column({ type: 'varchar', nullable: true })
   api_url: string;
 

package/src/module/dashboard/repository/dashboard.repository.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { DashboardPageData } from '../entity/dashboard_page_data.entity';
+import { WidgetMaster } from '../entity/widget_master.entity';
+
+@Injectable()
+export class DashboardRepository {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async getDashboardPageData(
+    pageId: number,
+    organization_id: number,
+  ): Promise<DashboardPageData | null> {
+    return await this.dataSource
+      .getRepository(DashboardPageData)
+      .createQueryBuilder('page')
+      .where('page.id = :pageId', { pageId })
+      .andWhere('page.organization_id = :organization_id', { organization_id })
+      .getOne();
+  }
+
+  async getWidgetsByIds(
+    widgetIds: number[],
+    organization_id: number,
+  ): Promise<WidgetMaster[]> {
+    if (!widgetIds.length) return [];
+    return await this.dataSource
+      .getRepository(WidgetMaster)
+      .createQueryBuilder('widget')
+      .where('widget.id IN (:...widgetIds)', { widgetIds })
+      .andWhere('widget.organization_id = :organization_id', {
+        organization_id,
+      })
+      .getMany();
+  }
+}

package/src/module/dashboard/service/dashboard.service.ts

@@ -0,0 +1,42 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DashboardRepository } from '../repository/dashboard.repository';
+
+@Injectable()
+export class DashboardService {
+  constructor(private readonly dashboardRepo: DashboardRepository) {}
+
+  async getDashboardPage(pageId: number, loggedInUser: any) {
+    const organizationId = loggedInUser.organization_id;
+    // 1. Get page data
+    const page = await this.dashboardRepo.getDashboardPageData(
+      pageId,
+      organizationId,
+    );
+    if (!page)
+      throw new NotFoundException(`Dashboard Page ${pageId} not found`);
+
+    const layout = page.layout_json || [];
+    const widgetIds = layout.map((b: any) => Number(b.w_id));
+
+    // 2. Fetch widget details
+    const widgets = await this.dashboardRepo.getWidgetsByIds(
+      widgetIds,
+      organizationId,
+    );
+
+    // Convert to map
+    const widgetMap = {};
+    widgets.forEach((w) => {
+      widgetMap[w.id] = w;
+    });
+
+    const { layout_json, ...pageData } = page;
+
+    // 3. Return
+    return {
+      page_data: pageData,
+      layout_json: layout,
+      widget_json: widgetMap,
+    };
+  }
+}

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

@@ -14,12 +14,14 @@ import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import { Request, Response } from 'express';
 import { UserSessionService } from '../service/user-session.service';
+import { ConfigService } from '@nestjs/config';
 
 @Controller('auth')
 export class LoginController {
   constructor(
     private loginService: LoginService,
     private userSessionService: UserSessionService,
+    private configService: ConfigService,
   ) {}
 
   @Post('login')
@@ -55,11 +57,12 @@ export class LoginController {
   // 2️⃣ Handles Google callback, validates user, creates session, and returns JWT
   @Get('google/callback')
   @UseGuards(GoogleAuthGuard)
-  async googleAuthRedirect(@Req() req) {
-    let { email, name } = req.user.userData; // Extracted from Google Strategy
+  async googleAuthRedirect(@Req() req: any, @Res() res: Response) {
+    let { email, name } = req.user; // Extracted from Google Strategy
 
     // Call LoginService to validate user, create session, and return JWT
-    return this.loginService.loginWithGoogle(email, name);
+    const token = await this.loginService.loginWithGoogle(email, name);
+    return res.redirect(`${this.configService.get('BASE_URL')}?token=${token}`);
   }
 
   @UseGuards(JwtAuthGuard)

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

@@ -235,22 +235,23 @@ export class LoginService {
     let user = await this.userService.findByEmailId(email);
 
     if (!user) {
+      return new BadRequestException('User not found');
       // If user doesn't exist, create a new user record
-      user = new UserData();
-      user.email_id = email;
-      user.first_name = name.givenName;
-      user.last_name = name.familyName;
-
-      user.name = user.first_name + ' ' + user.last_name;
-      let savedUserResponse = await this.userService.createEntity(user, null);
-
-      if (savedUserResponse.success) {
-        user = savedUserResponse.data as UserData;
-      } else {
-        throw new BadRequestException(
-          savedUserResponse.error || 'Failed to create user',
-        );
-      }
+      // user = new UserData();
+      // user.email_id = email;
+      // user.first_name = name.givenName;
+      // user.last_name = name.familyName;
+
+      // user.name = user.first_name + ' ' + user.last_name;
+      // // let savedUserResponse = await this.userService.createEntity(user, null);
+
+      // if (savedUserResponse.success) {
+      //   user = savedUserResponse.data as UserData;
+      // } else {
+      //   throw new BadRequestException(
+      //     savedUserResponse.error || 'Failed to create user',
+      //   );
+      // }
     }
 
     // Create session (Same as JWT login flow)

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

@@ -78,7 +78,7 @@ export class StageRepository {
     )) as StageGroup;
 
     if (!stageGroup) {
-      throw new NotFoundException('Stage group not found');
+      return [];
     }
 
     // 2. Fetch all groups + stages in one query
@@ -88,7 +88,7 @@ export class StageRepository {
       g.id as stage_group_id, g.name as stage_group_name, g.workflow_id,
       s.*
     FROM cr_wf_stage_group g
-    LEFT JOIN cr_wf_stage s ON s.stage_group_id = g.id
+    INNER JOIN cr_wf_stage s ON s.stage_group_id = g.id
     WHERE g.workflow_id = ? AND g.organization_id = ?
     ORDER BY g.id, s.id
     `,