rez_core 6.5.61 → 6.5.63

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

@@ -212,14 +212,6 @@ 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}`, {
@@ -259,7 +251,7 @@ export class ListMasterService {
 
     const resolveInactiveStatus = await this.getResolvedListCode(
       STATUS_INACTIVE,
-      loggedInUser?.organization_id || 0,
+      loggedInUser?.enterprise_id || 0,
     );
 
     // Fetch inactive records (with same filters but without status condition)
@@ -430,91 +422,373 @@ export class ListMasterService {
     entity_type: string,
     attribute_key: string,
     loggedInUser: UserData,
-    body: Record<string, string>,
+    body: Record<string, any>,
   ) {
-    let entityMaster = await this.entityMasterService.getEntityData(
-      entity_type,
-      loggedInUser,
-    );
-    let appCode = entityMaster.appcode;
+    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,
+        );
 
-    const { inactiveIds, ...params } = body;
+      if (!attributeMaster) {
+        throw new BadRequestException(
+          `Attribute '${attribute_key}' not found for entity '${entity_type}'`,
+        );
+      }
 
-    const inactiveIdsArray = inactiveIds
-      ? inactiveIds.split(',').map((id) => parseInt(id, 10))
-      : [];
+      // 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;
 
-    const currentAppCode = this.configService.get<string>('appcode');
+      if (!ds_category) {
+        throw new BadRequestException(
+          `Data source category not configured for attribute '${attribute_key}'`,
+        );
+      }
 
-    if (currentAppCode === appCode || !currentAppCode) {
-      const entityAttribute =
-        await this.attributeMasterService.findByMappedEntityTypeAndAttributeKey(
+      const currentAppCode = this.configService.get<string>('appcode');
+
+      // Check if request is for same app (SELF) or cross-app (CROSS)
+      const isSelfApp =
+        !ds_appcode ||
+        ds_appcode.toUpperCase() === 'SELF' ||
+        currentAppCode === ds_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,
           entity_type,
           attribute_key,
           loggedInUser,
+          body,
         );
+      }
+    } catch (error) {
+      console.error('❌ Error in getDropDownData:', error.message);
+      throw error;
+    }
+  }
 
-      if (entityAttribute && entityAttribute.data_source_type) {
-        const listMaster = await this.listMasterRepo.findByType(
-          entityAttribute.datasource_list,
-          loggedInUser?.enterprise_id,
+  /**
+   * 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,
         );
 
-        if (!listMaster) {
-          return;
-        }
+      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);
 
-        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}`,
-            );
+        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}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * 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;
         }
+
+        query = query.andWhere(`${tableName}.${key} = :${key}`, {
+          [key]: filterValue,
+        });
       }
-    } else {
-      const client = this.factory.getClient(appCode);
+    });
+
+    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);
 
       if (!client) {
-        return;
+        throw new BadRequestException(
+          `Microservice client for app '${targetAppCode}' not available`,
+        );
       }
 
-      return client
+      // Forward the request to target microservice
+      // The target microservice will execute the same process recursively
+      const response = await client
         .send('getDropdownData', {
           entity_type,
           attribute_key,
@@ -522,6 +796,94 @@ 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,16 +81,4 @@ 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,9 +33,8 @@ export class EntityDynamicController {
     if (!entityType) {
       throw new BadRequestException(`Query param "entity_type" is required`);
     }
-
-    return await this.entityDynamicService.createEntityWithRelation(
-      entityType,
+    data['entity_type'] = entityType;
+    return await this.entityDynamicService.createEntity(
       data,
       loggedInUser,
     );
@@ -63,10 +62,9 @@ export class EntityDynamicController {
     if (!existingEntity) {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
-
-    return await this.entityDynamicService.updateEntityWithRelations(
-      entityType,
-      id,
+    data['id'] = id;
+    data['entity_type'] = entityType;
+    return await this.entityDynamicService.updateEntity(
       data,
       loggedInUser,
     );
@@ -85,7 +83,7 @@ export class EntityDynamicController {
       throw new BadRequestException(`Query param "entity_type" is required`);
     }
 
-    const entity = await this.entityDynamicService.getEntityWithRelation(
+    const entity = await this.entityDynamicService.getEntityData(
       entityType,
       id,
       loggedInUser,

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

@@ -171,7 +171,6 @@ 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,17 +1,7 @@
-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')
@@ -19,9 +9,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)
@@ -64,18 +54,6 @@ 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)

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

@@ -89,4 +89,17 @@ export class AttributeMaster extends BaseEntity {
 
   @Column({ name: 'flat_json_key', nullable: true })
   flat_json_key: string;
+
+  // Dropdown data source fields
+  @Column({ name: 'ds_category', type: 'varchar', nullable: true, length: 50 })
+  ds_category: string;
+
+  @Column({ name: 'ds_entitytype', type: 'varchar', nullable: true, length: 255 })
+  ds_entitytype: string;
+
+  @Column({ name: 'ds_filtercode', type: 'varchar', nullable: true, length: 500 })
+  ds_filtercode: string;
+
+  @Column({ name: 'ds_appcode', type: 'varchar', nullable: true, length: 50 })
+  ds_appcode: string;
 }