rez_core 7.0.0 → 7.0.1

package/src/module/app_master/controller/app-master.controller.ts

@@ -1,56 +0,0 @@
-import {
-  Controller,
-  Get,
-  Query,
-  Res,
-  HttpStatus,
-  UseGuards,
-  Inject,
-  Req,
-} from '@nestjs/common';
-import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import { Response } from 'express';
-import { AppMasterService } from '../service/app-master.service';
-import { MessagePattern } from '@nestjs/microservices';
-
-@Controller('apps')
-export class AppMasterController {
-  constructor(private appMasterService: AppMasterService) {}
-
-  @Get('')
-  @UseGuards(JwtAuthGuard)
-  async getAppByAppCode(
-    @Req() req: Request & { user: any },
-    @Res() res: Response,
-  ) {
-    try {
-      const id = req.user.userData.id;
-
-      const data = await this.appMasterService.getAppMasterDataByAppCode(id);
-
-      return res.status(HttpStatus.OK).json(data);
-    } catch (error) {
-      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
-        success: false,
-        message: error.message || 'Error fetching entity data',
-      });
-    }
-  }
-
-  @Get('dropdown')
-  async getAllAppsDropdown(
-    @Res() res: Response,
-  ) {
-    try {
-      const data = await this.appMasterService.getAllAppsDropdown();
-
-      return res.status(HttpStatus.OK).json(data);
-    } catch (error) {
-      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
-        success: false,
-        message: error.message || 'Error fetching apps dropdown data',
-      });
-    }
-  }
-
-}

package/src/module/app_master/entity/app-master.entity.ts

@@ -1,50 +0,0 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'sso_app_master' })
-export class AppMaster {
-
-  @PrimaryGeneratedColumn()
-  id: number;
-  
-  @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true, length: 100 })
-  status: string;
-
-  @Column({ name: 'code', type: 'varchar', length: 100, nullable: true })
-  code: string;
-
-  @Column({ name: 'created_by', type: 'bigint', nullable: true })
-  created_by: number;
-
-  @Column({ name: 'created_date',nullable: true })
-  created_date: Date;
-
-  @Column({ name: 'modified_by', type: 'bigint', nullable: true })
-  modified_by: number;
-
-  @Column({ name: 'modified_date', nullable: true })
-  modified_date: Date;
-
-  @Column({ name: 'type', type: 'varchar', nullable: true })
-  type: string;
-
-  @Column({ name: 'color', type: 'varchar', nullable: true })
-  color: string;
-
-  @Column({ name: 'route', type: 'varchar', nullable: true })
-  route: string;
-
-  @Column({ name: 'description', type: 'varchar', nullable: true })
-  description: string;
-
-  @Column({ name: 'backgroudcolor', type: 'varchar', nullable: true })
-  backgroudcolor: string;
-
-  @Column({ name: 'iconname', type: 'varchar', nullable: true })
-  iconname: string;
-
-  @Column({ name: 'version', type: 'varchar', nullable: true })
-  version: string;
-}

package/src/module/app_master/repository/app-master.repository.ts

@@ -1,38 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { BaseEntity, Repository } from 'typeorm';
-import { AppMaster } from '../entity/app-master.entity';
-
-@Injectable()
-export class AppMasterRespository {
-  constructor(
-    @InjectRepository(AppMaster)
-    private readonly appMasterRespository: Repository<AppMaster>,
-  ) {}
-
-  async getAppMasterDataByAppCode(
-    appCode: string,
-  ): Promise<AppMaster[] | null> {
-    return await this.appMasterRespository.find({
-      where: { code: appCode },
-    });
-  }
-
-  async getDropdownData(data: any): Promise<AppMaster[]> {
-    const queryBuilder = this.appMasterRespository.createQueryBuilder('app_master');
-
-    if (data.type) {
-      queryBuilder.andWhere('app_master.type = :type', { type: data.type });
-    }
-
-    if (data.status) {
-      queryBuilder.andWhere('app_master.status = :status', { status: data.status });
-    }
-
-    return await queryBuilder.getMany();
-  }
-
-  async getAllApps(): Promise<AppMaster[]> {
-    return await this.appMasterRespository.find();
-  }
-}

package/src/module/app_master/service/app-master.service.ts

@@ -1,48 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { UserRoleMappingRepository } from 'src/module/user/repository/user-role-mapping.repository';
-import { AppMasterRespository } from '../repository/app-master.repository';
-import { UserRoleMappingService } from 'src/module/user/service/user-role-mapping.service';
-
-@Injectable()
-export class AppMasterService {
-  constructor(
-    private readonly appMasterRepository: AppMasterRespository,
-    private readonly userRoleMappingService:UserRoleMappingService
-  ) {}
-
-  async getAppMasterDataByAppCode(userId: number) {
-    const app_code =
-      await this.userRoleMappingService.findDistinctAppcodeByUserId(userId);
-
-    const finalResult: any[] = [];
-
-    if (app_code.appcode.length > 0) {
-      const resolvedData = await Promise.all(
-        app_code.appcode.map(async (element) => {
-          const data =
-            await this.appMasterRepository.getAppMasterDataByAppCode(element);
-          return data || [];
-        }),
-      );
-
-      resolvedData.flat().forEach((item) => {
-        finalResult.push({
-          key: item.name,
-          details: item,
-        });
-      });
-    }
-
-    return finalResult;
-  }
-
-
-  async getAllAppsDropdown() {
-    const apps = await this.appMasterRepository.getAllApps();
-    
-    return apps.map((app) => ({
-      label: app.name,
-      value: app.id,
-    }));
-  }
-}

package/src/module/auth/guards/role.guard.ts

@@ -1,68 +0,0 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { UserData } from '../../user/entity/user.entity';
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-@Injectable()
-export class RolesGuard implements CanActivate {
-  constructor(
-    private reflector: Reflector,
-    @InjectEntityManager() private entityManager: EntityManager,
-  ) {}
-
-  async canActivate(context: ExecutionContext) {
-    const request = context
-      .switchToHttp()
-      .getRequest<Request & { user: any }>();
-    const object = request.user;
-
-    const users: UserData = await this.entityManager.query(
-      `SELECT * FROM sso_user WHERE id = ${object.userId} LIMIT 1`,
-    );
-
-    const user = users[0];
-    if (!user || !user['role_id']) {
-      throw new UnauthorizedException('User not authorized');
-    }
-
-    const requiredModule = this.reflector.get<string>(
-      'moduleCode',
-      context.getHandler(),
-    );
-    const requiredActions = this.reflector.get<string>(
-      'actions',
-      context.getHandler(),
-    );
-
-    const roleAccess = await this.entityManager.query(
-      `SELECT *
-             FROM sso_module_access
-             WHERE role_id = ${user['role_id']}
-               AND module_code = '${requiredModule}'`,
-    );
-
-    if (!roleAccess || roleAccess.length === 0) {
-      throw new ForbiddenException(
-        'Access denied: No permissions found for this module',
-      );
-    }
-
-    const hasAccess = roleAccess.some(
-      (access) =>
-        requiredActions.includes(access.action_type) &&
-        access.access_flag === 1,
-    );
-
-    if (!hasAccess) {
-      throw new ForbiddenException('Access denied: Insufficient permissions.');
-    }
-    return true;
-  }
-}

package/src/module/enterprise/controller/enterprise.controller.ts

@@ -1,40 +0,0 @@
-import {
-  Controller,
-  Post,
-  Put,
-  Body,
-  HttpCode,
-  HttpStatus,
-  UseGuards,
-  Req,
-} from '@nestjs/common';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { EnterpriseService } from '../service/enterprise.service';
-import { EnterpriseData } from '../entity/enterprise.entity';
-
-@Controller('enterprise')
-@UseGuards(JwtAuthGuard)
-export class EnterpriseController {
-  constructor(private readonly enterpriseService: EnterpriseService) {}
-
-  @Post('create')
-  @HttpCode(HttpStatus.OK)
-  async create(
-    @Body() enterpriseData: EnterpriseData,
-    @Req() req: Request & { user: any },
-  ): Promise<EnterpriseData> {
-    const loggedInUser = req.user.userData;
-    return await this.enterpriseService.create(enterpriseData, loggedInUser);
-  }
-
-  @Put('update')
-  @HttpCode(HttpStatus.OK)
-  async update(
-    @Body() enterpriseData: EnterpriseData,
-    @Req() req: Request & { user: any },
-  ): Promise<EnterpriseData | null> {
-    const loggedInUser = req.user.userData;
-    return await this.enterpriseService.update(enterpriseData, loggedInUser);
-  }
-}
-

package/src/module/enterprise/controller/meta.controller.ts

@@ -1,23 +0,0 @@
-import { Controller, HttpCode, HttpStatus, Post, Query, Req, Res } from '@nestjs/common';
-import { Response } from 'express';
-import { PopulateMetaService } from '../service/populate-meta.service';
-
-@Controller('meta')
-export class MetaController {
-
-  constructor(private readonly populateMetaService: PopulateMetaService) {
-  }
-
-  @Post('populate')
-  @HttpCode(HttpStatus.OK)
-  async populateMetaData(
-    @Query('enterprise_id') enterpriseId: number,
-    @Query('organization_id') organizationId: number,
-    @Res() response: Response,
-    @Req() req: Request & { user: any },
-  ) {
-    const result =
-      await this.populateMetaService.populateMetaData(enterpriseId, organizationId);
-    return response.status(HttpStatus.OK).json(result);
-  }
-}

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

@@ -1,99 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Put,
-  Delete,
-  Body,
-  Param,
-  Inject,
-  Req,
-  UseGuards,
-  HttpCode,
-  HttpStatus,
-  ParseIntPipe,
-  BadRequestException,
-} from '@nestjs/common';
-import { Request } from 'express';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { UserService } from 'src/module/user/service/user.service';
-import { OrganizationService } from '../service/organization.service';
-import { OrganizationData } from '../entity/organization.entity';
-
-@Controller('organization')
-@UseGuards(JwtAuthGuard)
-export class OrganizationController {
-  constructor(
-    private readonly orgService: OrganizationService,
-  ) {}
-
-  @Post('create')
-  @HttpCode(HttpStatus.OK)
-  async create(
-    @Body() organizationDto: Partial<OrganizationData>,
-    @Req() req: Request & { user: any },
-  ): Promise<OrganizationData> {
-    const loggedInUser = req.user.userData;
-    return await this.orgService.create(organizationDto, loggedInUser);
-  }
-
-  @Get('dropdown')
-  @HttpCode(HttpStatus.OK)
-  async getOrganizationDropdown(@Req() req: Request & { user: any }) {
-    const userData = req.user.userData;
-    // const userData = await this.userService.getEntityData(ENTITYTYPE_USER, userId);
-    // const enterpriseId = req.user['enterpriseId']; // or adapt based on your user structure
-    return this.orgService.findById(userData?.organization_id);
-  }
-
-  @Get('hierarchy')
-  @HttpCode(HttpStatus.OK)
-  async getOrganizationHierarchy(@Req() req: Request & { user: any }) {
-    const userId = req.user.userData?.id;
-    const appcode = req.user.userData?.appcode;
-    const org_id = req.user.userData?.organization_id;
-
-    return await this.orgService.getOrganizationHierarchy(
-      userId,
-      appcode,
-      org_id,
-    );
-  }
-
-  @Get()
-  @HttpCode(HttpStatus.OK)
-  async findAll(): Promise<OrganizationData[]> {
-    return await this.orgService.findAll();
-  }
-
-  @Get(':id')
-  @HttpCode(HttpStatus.OK)
-  async findOne(
-    @Param('id', ParseIntPipe) id: number,
-  ): Promise<OrganizationData | null> {
-    return await this.orgService.findOne(id);
-  }
-
-  @Post('update/:id')
-  @HttpCode(HttpStatus.OK)
-  async update(
-    @Param('id', ParseIntPipe) id: number,
-    @Body() organizationDto: Partial<OrganizationData>,
-    @Req() req: Request & { user: any },
-  ): Promise<OrganizationData> {
-    const loggedInUser = req.user.userData;
-    const result = await this.orgService.update(id, organizationDto, loggedInUser);
-    
-    if (!result.success) {
-      throw new BadRequestException(result.error);
-    }
-    
-    return result.data;
-  }
-
-  @Delete(':id')
-  @HttpCode(HttpStatus.OK)
-  async remove(@Param('id', ParseIntPipe) id: number): Promise<void> {
-    return await this.orgService.remove(id);
-  }
-}

package/src/module/enterprise/enterprise.module.ts

@@ -1,43 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { OrganizationService } from './service/organization.service';
-import { OrganizationData } from './entity/organization.entity';
-import { OrganizationController } from './controller/organization.controller';
-import { OrganizationAppMappingService } from './service/organization-app-mapping.service';
-import { OrganizationAppMapping } from './entity/organization-app-mapping.entity';
-// import { BrandData } from './entity/brand.entity';
-// import { SchoolData } from './entity/school.entity';
-// import { BrandRepository } from './repository/brand.repository';
-import { UtilsModule } from 'src/utils/utils.module';
-import { OrganizationRepository } from './repository/organization.repository';
-import { SchoolRepository } from './repository/school.repository';
-import { EnterpriseService } from './service/enterprise.service';
-import { EnterpriseRepository } from './repository/enterprise.repository';
-import { EnterpriseData } from './entity/enterprise.entity';
-import { EnterpriseController } from './controller/enterprise.controller';
-import { PopulateMetaService } from './service/populate-meta.service';
-import { MetaController } from './controller/meta.controller';
-
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([
-      OrganizationData,
-      OrganizationAppMapping,
-      EnterpriseData,
-    ]),
-    UtilsModule,
-  ],
-  controllers: [OrganizationController, EnterpriseController, MetaController],
-  providers: [
-    OrganizationService,
-    OrganizationAppMappingService,
-    SchoolRepository,
-    OrganizationRepository,
-    EnterpriseService,
-    EnterpriseRepository,
-    PopulateMetaService
-  ],
-  exports: [OrganizationService, OrganizationRepository, EnterpriseService, EnterpriseRepository, PopulateMetaService],
-})
-export class EnterpriseModule {
-}

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

@@ -1,31 +0,0 @@
-import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
-
-@Entity({ name: 'sso_enterprise' })
-export class EnterpriseData {
-  @PrimaryGeneratedColumn({ name: 'id', type: 'bigint' })
-  id: number;
-
-  @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
-  code: string;
-
-  @Column({ name: 'name', type: 'varchar', nullable: true, length: 50 })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true, length: 50 })
-  status: string;
-
-  @Column({ name: 'created_by', type: 'int', nullable: true })
-  created_by: number;
-
-  @Column({ name: 'modified_by', type: 'int', nullable: true })
-  modified_by: number;
-
-  @CreateDateColumn({ name: 'created_date', nullable: true })
-  created_date: Date;
-
-  @UpdateDateColumn({ name: 'modified_date', nullable: true })
-  modified_date: Date;
-
-  @Column({ name: 'slug', type: 'varchar', nullable: true, length: 50 })
-  slug: string;
-}

package/src/module/enterprise/entity/organization-app-mapping.entity.ts

@@ -1,27 +0,0 @@
-import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, Unique } from 'typeorm';
-import { OrganizationData } from './organization.entity';
-import { AppMaster } from '../../app_master/entity/app-master.entity';
-
-@Entity({ name: 'sso_organization_app_mapping' })
-@Unique(['organization', 'app'])
-export class OrganizationAppMapping {
-  @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
-  id: number;
-
-  @Column({ type: 'int', nullable: true })
-  organization_id: number;
-
-  @ManyToOne(() => OrganizationData, { nullable: true, onDelete: 'SET NULL' })
-  @JoinColumn({ name: 'organization_id', referencedColumnName: 'id' })
-  organization: OrganizationData;
-
-  @Column({ type: 'int', nullable: true })
-  app_id: number;
-
-  @ManyToOne(() => AppMaster, { nullable: true, onDelete: 'SET NULL' })
-  @JoinColumn({ name: 'app_id', referencedColumnName: 'id' })
-  app: AppMaster;
-
-  @Column({type: 'varchar', nullable: true})
-  appcode: string;
-}

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

@@ -1,45 +0,0 @@
-import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
-import { EnterpriseData } from './enterprise.entity';
-
-@Entity({ name: 'sso_organization' })
-export class OrganizationData {
-  @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
-  id: number;
-
-  @Column({type: 'int', nullable: true})
-  enterprise_id: number;
-
-  @ManyToOne(() => EnterpriseData, {nullable: true, onDelete: 'SET NULL'})
-  @JoinColumn({ name: 'enterprise_id', referencedColumnName: 'id' })
-  enterprise: EnterpriseData;
-
-  @Column({ name: 'code', nullable: true })
-  code: string;
-
-  @Column({ name: 'name', nullable: true })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true })
-  status: string;
-
-  @Column({ name: 'parent_id', nullable: true })
-  parent_id: number;
-
-  @Column({ name: 'created_by', nullable: true })
-  created_by: number;
-
-  @Column({ name: 'modified_by', nullable: true })
-  modified_by: number;
-
-  @CreateDateColumn({ name: 'created_date', nullable: true })
-  created_date: Date;
-
-  @UpdateDateColumn({ name: 'modified_date', nullable: true })
-  modified_date: Date;
-
-  @Column({ name: 'wbs_code', nullable: true })
-  wbs_code: string;
-
-  @Column({ name: 'slug', nullable: true })
-  slug: string;
-}

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

@@ -1,53 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { EnterpriseData } from '../entity/enterprise.entity';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class EnterpriseRepository {
-  constructor(
-    @InjectRepository(EnterpriseData)
-    private readonly enterpriseRepository: Repository<EnterpriseData>,
-  ) {}
-
-  async save(enterpriseData: EnterpriseData, loggedInUser: any) {
-    if (loggedInUser) {
-      enterpriseData.created_by = loggedInUser.id;
-      enterpriseData.modified_by = loggedInUser.id;
-    }
-    return await this.enterpriseRepository.save(enterpriseData);
-  }
-
-  async update(
-    enterpriseData: EnterpriseData,
-    loggedInUser: any,
-  ): Promise<EnterpriseData | null> {
-    const existingEnterprise = await this.enterpriseRepository.findOne({
-      where: { id: enterpriseData.id },
-    });
-    if (!existingEnterprise) {
-      throw new Error(`Enterprise with id ${enterpriseData.id} not found`);
-    }
-    if (loggedInUser) {
-      enterpriseData.modified_by = loggedInUser.id;
-    }
-    await this.enterpriseRepository.update(enterpriseData.id, enterpriseData);
-    return await this.enterpriseRepository.findOne({
-      where: { id: enterpriseData.id },
-    });
-  }
-
-  async findEnterpriseBySubdomain(
-    slug: string,
-  ): Promise<EnterpriseData | null> {
-    return await this.enterpriseRepository.findOne({
-      where: { slug },
-    });
-  }
-
-  async findById(id: number) {
-    return await this.enterpriseRepository.findOne({
-      where: { id },
-    });
-  }
-}

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

@@ -1,26 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { OrganizationData } from '../entity/organization.entity';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class OrganizationRepository {
-  constructor(
-    @InjectRepository(OrganizationData)
-    private readonly organizationRepository: Repository<OrganizationData>,
-  ) {}
-
-  async findOrganizationById(id: number): Promise<OrganizationData | null> {
-    return await this.organizationRepository.findOne({
-      where: { id },
-    });
-  }
-
-  async findOrganizationBySubdomain(
-    subdomain: string,
-  ): Promise<OrganizationData | null> {
-    return await this.organizationRepository.findOne({
-      where: { slug: subdomain },
-    });
-  }
-}