rez_core 6.5.59 → 6.5.61

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

@@ -212,6 +212,14 @@ export class ListMasterService {
         });
       }
 
+      if (loggedInUser?.appcode && sourceList === 'ROL') {
+        if (!this.skipLevelFilterEntities.includes(sourceList)) {
+          qb.andWhere(`${tableName}.appcode = :appcode`, {
+            appcode: loggedInUser.appcode,
+          });
+        }
+      }
+
       // ✅ Apply dynamic params
       for (const key in params) {
         qb.andWhere(`${tableName}.${key} = :${key}`, {
@@ -251,7 +259,7 @@ export class ListMasterService {
 
     const resolveInactiveStatus = await this.getResolvedListCode(
       STATUS_INACTIVE,
-      loggedInUser?.enterprise_id || 0,
+      loggedInUser?.organization_id || 0,
     );
 
     // Fetch inactive records (with same filters but without status condition)
@@ -422,373 +430,91 @@ export class ListMasterService {
     entity_type: string,
     attribute_key: string,
     loggedInUser: UserData,
-    body: Record<string, any>,
+    body: Record<string, string>,
   ) {
-    try {
-      // Extract inactiveIds from body
-      const { inactiveIds, ...params } = body;
-      const inactiveIdsArray = inactiveIds
-        ? inactiveIds.split(',').map((id) => parseInt(id, 10))
-        : [];
-
-      // Fetch Attribute Master to get data source configuration
-      const attributeMaster =
-        await this.attributeMasterService.findByMappedEntityTypeAndAttributeKey(
-          entity_type,
-          attribute_key,
-          loggedInUser,
-        );
-
-      if (!attributeMaster) {
-        throw new BadRequestException(
-          `Attribute '${attribute_key}' not found for entity '${entity_type}'`,
-        );
-      }
-
-      // Extract data source configuration from AttributeMaster
-      const {
-        ds_category,    // ENT_LIST | LM | CAPI | CK | EXTAPI
-        ds_entitytype,  // Entity type or list code
-        ds_filtercode,  // Additional filter code
-        ds_appcode,     // Target app code
-      } = attributeMaster;
+    let entityMaster = await this.entityMasterService.getEntityData(
+      entity_type,
+      loggedInUser,
+    );
+    let appCode = entityMaster.appcode;
 
-      if (!ds_category) {
-        throw new BadRequestException(
-          `Data source category not configured for attribute '${attribute_key}'`,
-        );
-      }
+    const { inactiveIds, ...params } = body;
 
-      const currentAppCode = this.configService.get<string>('appcode');
+    const inactiveIdsArray = inactiveIds
+      ? inactiveIds.split(',').map((id) => parseInt(id, 10))
+      : [];
 
-      // Check if request is for same app (SELF) or cross-app (CROSS)
-      const isSelfApp =
-        !ds_appcode ||
-        ds_appcode.toUpperCase() === 'SELF' ||
-        currentAppCode === ds_appcode;
+    const currentAppCode = this.configService.get<string>('appcode');
 
-      if (isSelfApp) {
-        // SELF APP - Process locally
-        return this.processLocalDropdown(
-          ds_category,
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          inactiveIdsArray,
-          loggedInUser,
-        );
-      } else {
-        // CROSS APP - Forward to target microservice
-        return this.processCrossAppDropdown(
-          ds_appcode,
+    if (currentAppCode === appCode || !currentAppCode) {
+      const entityAttribute =
+        await this.attributeMasterService.findByMappedEntityTypeAndAttributeKey(
           entity_type,
           attribute_key,
           loggedInUser,
-          body,
         );
-      }
-    } catch (error) {
-      console.error('❌ Error in getDropDownData:', error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Process dropdown data locally (SELF APP)
-   */
-  private async processLocalDropdown(
-    ds_category: string,
-    ds_entitytype: string,
-    ds_filtercode: string,
-    params: Record<string, any>,
-    inactiveIdsArray: number[],
-    loggedInUser: UserData,
-  ) {
-    // Route to appropriate handler based on data source category
-    switch (ds_category.toUpperCase()) {
-      case 'ENT_LIST':
-      case 'ENTITY':
-        // Merge ds_filtercode params with request params
-        const mergedParams = { ...params };
-        if (ds_filtercode) {
-          const filterParams = this.parseFilterCode(ds_filtercode);
-          Object.assign(mergedParams, filterParams);
-        }
-        return this.fetchFromEntity(
-          ds_entitytype,
-          mergedParams,
-          inactiveIdsArray,
-          loggedInUser,
-        );
-
-      case 'LM':
-      case 'LIST_MASTER':
-        return this.fetchFromListMaster(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          inactiveIdsArray,
-          loggedInUser,
-        );
-
-      case 'CAPI':
-      case 'CUSTOM_API':
-        return this.fetchFromCustomInternalService(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      case 'CK':
-      case 'CUSTOM_KEY':
-        return this.fetchFromCustomKey(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      case 'EXTAPI':
-      case 'EXTERNAL_API':
-        return this.fetchFromExternalAPI(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      default:
-        throw new BadRequestException(
-          `Unsupported data source category: ${ds_category}`,
-        );
-    }
-  }
-
-  /**
-   * Fetch dropdown from List Master
-   */
-  private async fetchFromListMaster(
-    lmCode: string,
-    filterCode: string,
-    params: Record<string, any>,
-    inactiveIdsArray: number[],
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Get List Master configuration
-      const listMaster = await this.listMasterRepo.findByType(
-        lmCode,
-        loggedInUser.enterprise_id,
-      );
-
-      if (!listMaster) {
-        throw new BadRequestException(`List Master '${lmCode}' not found`);
-      }
-
-      // Use repository to fetch items directly with filter
-      return this.listItemsRepo.findItemsByType(
-        lmCode,
-        listMaster.sort_by,
-        inactiveIdsArray,
-        loggedInUser.enterprise_id,
-        params,
-      );
-    } catch (error) {
-      console.error(`❌ Error fetching from List Master '${lmCode}':`, error.message);
-      throw new BadRequestException(
-        `Failed to fetch from List Master: ${error.message}`,
-      );
-    }
-  }
-
-  /**
-   * Fetch dropdown from Custom Internal Service (Message Pattern)
-   */
-  private async fetchFromCustomInternalService(
-    serviceName: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Get internal service client
-      const client = this.factory.getClient('INTERNAL_SERVICE');
-
-      if (!client) {
-        throw new BadRequestException('Internal service client not available');
-      }
-
-      // Call internal microservice using message pattern
-      const response = await client
-        .send(serviceName, {
-          filterCode,
-          params,
-          loggedInUser,
-        })
-        .toPromise();
-
-      return response;
-    } catch (error) {
-      console.error(
-        `❌ Error calling custom internal service '${serviceName}':`,
-        error.message,
-      );
-      throw new BadRequestException(
-        `Failed to call custom internal service: ${error.message}`,
-      );
-    }
-  }
-
-  /**
-   * Fetch dropdown from Custom Key (Predefined logic)
-   */
-  private async fetchFromCustomKey(
-    customKey: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Handle predefined custom logic based on custom key
-      switch (customKey.toUpperCase()) {
-        case 'USER_ROLES':
-          return this.getUserRolesDropdown(filterCode, params, loggedInUser);
-
-        case 'DEPARTMENTS':
-          return this.getDepartmentsDropdown(filterCode, params, loggedInUser);
-
-        case 'FINANCIAL_YEARS':
-          return this.getFinancialYearsDropdown(filterCode, params, loggedInUser);
-
-        case 'OPERATORS':
-          return this.getOperatorsDropdown(filterCode, params, loggedInUser);
-
-        // Add more custom key handlers as needed
-        default:
-          throw new BadRequestException(`Unknown custom key: ${customKey}`);
-      }
-    } catch (error) {
-      console.error(`❌ Error fetching custom key '${customKey}':`, error.message);
-      throw new BadRequestException(
-        `Failed to fetch custom key: ${error.message}`,
-      );
-    }
-  }
 
-  /**
-   * Fetch dropdown from External API
-   */
-  private async fetchFromExternalAPI(
-    apiUrl: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Build full API URL with filter code if provided
-      const fullUrl = filterCode ? `${apiUrl}/${filterCode}` : apiUrl;
-
-      // Make external API call using Axios
-      const response = await axios.get(fullUrl, {
-        params: {
-          ...params,
-          enterprise_id: loggedInUser.enterprise_id,
-        },
-        timeout: 10000, // 10 seconds timeout
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.configService.get('EXTERNAL_API_TOKEN')}`,
-        },
-      });
-
-      return response.data;
-    } catch (error) {
-      console.error(`❌ Error calling external API '${apiUrl}':`, error.message);
-
-      if (error.response) {
-        throw new BadRequestException(
-          `External API error: ${error.response.status} - ${error.response.statusText}`,
-        );
-      } else if (error.request) {
-        throw new BadRequestException('External API is not responding');
-      } else {
-        throw new BadRequestException(
-          `Failed to call external API: ${error.message}`,
+      if (entityAttribute && entityAttribute.data_source_type) {
+        const listMaster = await this.listMasterRepo.findByType(
+          entityAttribute.datasource_list,
+          loggedInUser?.enterprise_id,
         );
-      }
-    }
-  }
 
-  /**
-   * Apply filter code to query (custom WHERE conditions)
-   */
-  private applyFilterCode(
-    query: any,
-    tableName: string,
-    filterCode: string,
-    loggedInUser: UserData,
-  ): any {
-    // Parse filter code and apply conditions
-    // Example: "status=active|type=premium"
-    const filters = filterCode.split('|');
-
-    filters.forEach((filter) => {
-      const [key, value] = filter.split('=');
-      if (key && value) {
-        // Handle special variables
-        let filterValue: any = value;
-        if (value === '{USER_ID}') {
-          filterValue = loggedInUser.id;
-        } else if (value === '{ENTERPRISE_ID}') {
-          filterValue = loggedInUser.enterprise_id;
+        if (!listMaster) {
+          return;
         }
 
-        query = query.andWhere(`${tableName}.${key} = :${key}`, {
-          [key]: filterValue,
-        });
+        switch (listMaster.source) {
+          case 'entity':
+            return this.fetchFromEntity(
+              listMaster.type,
+              params,
+              inactiveIdsArray,
+              loggedInUser,
+            );
+
+          case 'master':
+            return this.listItemsRepo.findItemsByType(
+              listMaster.type,
+              listMaster.sort_by,
+              inactiveIdsArray,
+              loggedInUser.enterprise_id,
+              params,
+            );
+
+          case 'operator':
+            return this.listItemsRepo.findOperatorsByType(
+              listMaster?.type,
+              loggedInUser?.enterprise_id,
+            );
+
+          case 'custom':
+            // If you want Axios call here too:
+            try {
+              const response = await axios.get(
+                `https://external-source.com/${listMaster.custom_source_id}`,
+                { params },
+              );
+              return response.data;
+            } catch (error) {
+              console.error('⚠️ Custom source fetch failed:', error.message);
+              throw new BadRequestException('Failed to fetch custom source');
+            }
+
+          default:
+            throw new BadRequestException(
+              `Unknown source: ${listMaster.source}`,
+            );
+        }
       }
-    });
-
-    return query;
-  }
-
-  /**
-   * Format dropdown response with consistent structure
-   */
-  private formatDropdownResponse(data: any[], config: any): any[] {
-    return data.map((item) => ({
-      id: item.id,
-      value: item.value || item.name || item.title,
-      label: item.label || item.display_name || item.name || item.title,
-      code: item.code,
-      ...item, // Include all other fields
-    }));
-  }
-
-  /**
-   * Forward request to cross-app microservice (CROSS APP)
-   */
-  private async processCrossAppDropdown(
-    targetAppCode: string,
-    entity_type: string,
-    attribute_key: string,
-    loggedInUser: UserData,
-    body: Record<string, any>,
-  ) {
-    try {
-      // Get microservice client for target app
-      const client = this.factory.getClient(targetAppCode);
+    } else {
+      const client = this.factory.getClient(appCode);
 
       if (!client) {
-        throw new BadRequestException(
-          `Microservice client for app '${targetAppCode}' not available`,
-        );
+        return;
       }
 
-      // Forward the request to target microservice
-      // The target microservice will execute the same process recursively
-      const response = await client
+      return client
         .send('getDropdownData', {
           entity_type,
           attribute_key,
@@ -796,94 +522,6 @@ export class ListMasterService {
           body,
         })
         .toPromise();
-
-      return response;
-    } catch (error) {
-      console.error(
-        `❌ Error calling cross-app microservice '${targetAppCode}':`,
-        error.message,
-      );
-      throw new BadRequestException(
-        `Failed to fetch dropdown from app '${targetAppCode}': ${error.message}`,
-      );
-    }
-  }
-
-  // Example custom key handlers
-  private async getUserRolesDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // TODO: Implement roles service integration
-    // return this.rolesService.getActiveRoles(loggedInUser.enterprise_id, params);
-    throw new BadRequestException('USER_ROLES handler not implemented yet');
-  }
-
-  private async getDepartmentsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // TODO: Implement departments service integration
-    // return this.departmentService.getActiveDepartments(loggedInUser.enterprise_id, params);
-    throw new BadRequestException('DEPARTMENTS handler not implemented yet');
-  }
-
-  private async getFinancialYearsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // Generate financial years dynamically
-    const currentYear = new Date().getFullYear();
-    const years: Array<{ id: number; value: string; label: string }> = [];
-    for (let i = -5; i <= 5; i++) {
-      const year = currentYear + i;
-      years.push({
-        id: year,
-        value: `FY${year}-${year + 1}`,
-        label: `FY ${year}-${year + 1}`,
-      });
     }
-    return years;
-  }
-
-  private async getOperatorsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // Return predefined operators
-    return [
-      { id: 1, value: '=', label: 'Equals' },
-      { id: 2, value: '!=', label: 'Not Equals' },
-      { id: 3, value: '>', label: 'Greater Than' },
-      { id: 4, value: '<', label: 'Less Than' },
-      { id: 5, value: '>=', label: 'Greater Than or Equal' },
-      { id: 6, value: '<=', label: 'Less Than or Equal' },
-      { id: 7, value: 'LIKE', label: 'Contains' },
-      { id: 8, value: 'IN', label: 'In List' },
-    ];
-  }
-
-  /**
-   * Parse filter code string into key-value params
-   * Example: "status=active|type=premium" => { status: 'active', type: 'premium' }
-   */
-  private parseFilterCode(filterCode: string): Record<string, any> {
-    if (!filterCode) return {};
-
-    const params: Record<string, any> = {};
-    const filters = filterCode.split('|');
-
-    filters.forEach((filter) => {
-      const [key, value] = filter.split('=');
-      if (key && value) {
-        params[key.trim()] = value.trim();
-      }
-    });
-
-    return params;
   }
 }

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

@@ -81,4 +81,16 @@ export class AttributeMasterController {
       loggedInUser,
     );
   }
+  
+  @Get('getAll/:entityType')
+  async getAttributes(
+    @Param('entityType') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getAttributes(
+      entityType,
+      loggedInUser,
+    );
+  }
 }

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

@@ -33,8 +33,9 @@ export class EntityDynamicController {
     if (!entityType) {
       throw new BadRequestException(`Query param "entity_type" is required`);
     }
-    data['entity_type'] = entityType;
-    return await this.entityDynamicService.createEntity(
+
+    return await this.entityDynamicService.createEntityWithRelation(
+      entityType,
       data,
       loggedInUser,
     );
@@ -62,9 +63,10 @@ export class EntityDynamicController {
     if (!existingEntity) {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
-    data['id'] = id;
-    data['entity_type'] = entityType;
-    return await this.entityDynamicService.updateEntity(
+
+    return await this.entityDynamicService.updateEntityWithRelations(
+      entityType,
+      id,
       data,
       loggedInUser,
     );
@@ -83,7 +85,7 @@ export class EntityDynamicController {
       throw new BadRequestException(`Query param "entity_type" is required`);
     }
 
-    const entity = await this.entityDynamicService.getEntityData(
+    const entity = await this.entityDynamicService.getEntityWithRelation(
       entityType,
       id,
       loggedInUser,

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

@@ -171,6 +171,7 @@ export class EntityController {
       entityData,
       loggedInUser as UserData,
       null,
+      appcode,
     );
 
     // ✅ Run workflow automation (no preUpdateStates for CREATE)

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

@@ -1,7 +1,17 @@
-import { Body, Controller, HttpCode, HttpStatus, Post, Query, Req, Res, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller, HttpCode,
+  HttpStatus,
+  Post,
+  Query,
+  Req,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
 import { EntityTableService } from '../service/entity-table.service';
 import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { PopulateMetaService } from '../service/populate-meta.service';
 import { EntityMasterService } from '../service/entity-master.service';
 
 @Controller('meta')
@@ -9,9 +19,9 @@ import { EntityMasterService } from '../service/entity-master.service';
 export class MetaController {
   constructor(
     private readonly entityTableService: EntityTableService,
+    private readonly populateMetaService: PopulateMetaService,
     private readonly entityMaster: EntityMasterService,
-  ) {
-  }
+  ) {}
 
   @Post('get-table-data')
   @HttpCode(HttpStatus.OK)
@@ -54,6 +64,18 @@ export class MetaController {
     });
   }
 
+  @Post('populate')
+  @HttpCode(HttpStatus.OK)
+  async populateMetaData(
+    @Query('organization_id') organizationId: number,
+    @Res() response: Response,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result =
+      await this.populateMetaService.populateMetaData(organizationId);
+    return response.status(HttpStatus.OK).json(result);
+  }
 
   @Post('operation-list')
   @HttpCode(HttpStatus.OK)