@techextensor/tab-core-utility 2.2.129 → 2.2.131

package/esm2022/lib/tab-core-utility/app/helpers/common/meta-data.helpers.mjs

@@ -0,0 +1,661 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from "@angular/core";
+import { MetadataEntityType } from "../../interfaces/schema.interface";
+import { Common } from "../../constants/common";
+import * as i0 from "@angular/core";
+/**
+   * MetadataUtils - Utility service for retrieving and manipulating application metadata
+   *
+   * This service provides methods to extract, filter, and format different parts of the
+   * application metadata, including objects, fields, screens, menus, etc.
+   */
+export class MetadataHelper {
+    // Helper method to consistently format results
+    formatResults(items, columns) {
+        if (!columns || columns.length === 0) {
+            return items;
+        }
+        return items.map(item => {
+            const result = {};
+            columns.forEach(col => {
+                result[col] = item[col];
+            });
+            return result;
+        });
+    }
+    /**
+     * Search across all metadata for a term
+     *
+     * @param searchTerm Term to search for
+     * @param entityTypes Optional types of entities to search (if not provided, searches all)
+     * @returns Search results grouped by entity type
+     *
+     * @example
+     * // Search across all metadata
+     * const results = metadataUtils.searchAcrossMetadata('Blueprint');
+     *
+     * // Search only in app objects and screens
+     * const results = metadataUtils.searchAcrossMetadata(
+     *   'Role',
+     *   [MetadataEntityType.APP_OBJECTS, MetadataEntityType.APP_SCREENS]
+     * );
+     */
+    searchAcrossMetadata(searchTerm, entityTypes) {
+        try {
+            if (!searchTerm || searchTerm.trim() === '') {
+                return {};
+            }
+            const term = searchTerm.toLowerCase();
+            const results = {};
+            // If entityTypes not provided, search all entity types
+            const typesToSearch = entityTypes || Object.values(MetadataEntityType);
+            // Execute search for each entity type
+            if (typesToSearch.includes(MetadataEntityType.APP_OBJECTS)) {
+                results[MetadataEntityType.APP_OBJECTS] = this.searchAppObjects(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_FIELDS)) {
+                results[MetadataEntityType.APP_FIELDS] = this.searchAppFields(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.DATA_SOURCE_QUERIES)) {
+                results[MetadataEntityType.DATA_SOURCE_QUERIES] = this.searchDataSourceQueries(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_SCREENS)) {
+                results[MetadataEntityType.APP_SCREENS] = this.searchAppScreens(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_MENUS)) {
+                results[MetadataEntityType.APP_MENUS] = this.searchAppMenus(term);
+            }
+            return results;
+        }
+        catch (error) {
+            console.error('Error in searchMetadata:', error);
+            return {};
+        }
+    }
+    /**
+     * Search for a term within App Objects
+     * @private
+     */
+    searchAppObjects(term) {
+        return this.getAppObjects(obj => this.containsTerm(obj.ObjectName, term) ||
+            this.containsTerm(obj.DisplayName, term) ||
+            this.containsTerm(obj.Description, term) ||
+            this.containsTerm(obj.SystemDBTableName, term));
+    }
+    /**
+     * Search for a term within App Fields
+     * @private
+     */
+    searchAppFields(term) {
+        return this.getAppFields(field => this.containsTerm(field.FieldName, term) ||
+            this.containsTerm(field.DisplayName, term) ||
+            this.containsTerm(field.Description, term) ||
+            this.containsTerm(field.SystemDBFieldName, term));
+    }
+    /**
+     * Search for a term within Data Source Queries
+     * @private
+     */
+    searchDataSourceQueries(term) {
+        return this.getDataSourceQueries(query => this.containsTerm(query.QueryName, term) ||
+            this.containsTerm(query.DisplayName, term));
+    }
+    /**
+     * Search for a term within App Screens
+     * @private
+     */
+    searchAppScreens(term) {
+        return this.getAppScreens(screen => this.containsTerm(screen.Name, term) ||
+            this.containsTerm(screen.Description, term));
+    }
+    /**
+     * Search for a term within App Menus
+     * @private
+     */
+    searchAppMenus(term) {
+        return this.getAppMenus(menu => this.containsTerm(menu.MenuName, term) ||
+            this.containsTerm(menu.DisplayName, term));
+    }
+    /**
+     * Helper method to check if a string contains a search term
+     * @private
+     */
+    containsTerm(value, term) {
+        return !!value && value.toLowerCase().includes(term);
+    }
+    /**
+     * Gets App Objects based on filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app objects
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app objects
+     *
+     * @example
+     * // Get all system app objects
+     * const systemObjects = metadataUtils.getAppObjects(obj => obj.IsSystem === true);
+     *
+     * // Get specific columns from non-deprecated objects
+     * const objects = metadataUtils.getAppObjects(
+     *   obj => !obj.IsDeprecated,
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjects(filterFn, columns) {
+        try {
+            let appObjects = Common.tabJson.AppObjects || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appObjects = appObjects.filter(filterFn);
+            }
+            // Return all object data if no columns specified
+            return this.formatResults(appObjects, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjects:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific App Object by ID or Name
+     *
+     * @param appObject ID or Name of the app object to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app object with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific app object with all properties
+     * const appObj = metadataUtils.getAppObjectDetails('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get specific columns from an app object
+     * const appObj = metadataUtils.getAppObjectDetails(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjectDetails(appObject, columns) {
+        try {
+            return this.getAppObjects(obj => obj.ID?.toLowerCase() === appObject?.toLowerCase() || obj.ObjectName === appObject, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getAppObjectById:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets all fields across all app objects with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered fields
+     *
+     * @example
+     * // Get all required fields across all objects
+     * const requiredFields = metadataUtils.getAppFields(field => field.IsRequired === true);
+     *
+     * // Get specific columns from searchable fields
+     * const fields = metadataUtils.getAppFields(
+     *   field => field.IsSearchable === true,
+     *   ['ID', 'DisplayName', 'FieldName']
+     * );
+     */
+    getAppFields(filterFn, columns) {
+        try {
+            // Get all fields from all app objects
+            const allFields = [];
+            Common.tabJson.AppObjects.forEach((obj) => {
+                allFields.push(...obj.Fields);
+            });
+            // Apply filter if provided
+            let filteredFields = allFields;
+            if (filterFn) {
+                filteredFields = allFields.filter(filterFn);
+            }
+            // Return all field data if no columns specified
+            return this.formatResults(filteredFields, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets fields for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for fields
+     * @returns Array of fields for the specified object
+     *
+     * @example
+     * // Get all fields for an object
+     * const fields = metadataUtils.getAppFieldsByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get only required fields
+     * const requiredFields = metadataUtils.getAppFieldsByAppObject(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   field => field.IsRequired === true
+     * );
+     */
+    getAppFieldsByAppObject(appObject, filterFn, columns) {
+        try {
+            const filteredAppObject = this.getAppObjectDetails(appObject);
+            if (!filteredAppObject) {
+                return [];
+            }
+            let fields = filteredAppObject.Fields || [];
+            // Apply filter if provided
+            if (filterFn) {
+                fields = fields.filter(filterFn);
+            }
+            return this.formatResults(fields, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppFieldById:', error);
+            return [];
+        }
+    }
+    /**
+    * Gets lookup fields for a specific app object
+    *
+    * @param appObject ID or Name of the app object
+    * @param filterFn Optional filter function for lookup fields
+    * @param columns Optional columns to include in the result
+    * @returns Array of lookup fields for the specified object
+    *
+    * @example
+    * // Get all lookup fields for an object
+    * const lookupFields = metadataUtils.getLookupFieldsByAppObject('TABD_Blueprint_SLASchemes');
+    *
+    * // Get specific lookup fields
+    * const fields = metadataUtils.getLookupFieldsByAppObject(
+    *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+    *   field => field.IsRequired === true
+    * );
+    */
+    getLookupFieldsByAppObject(appObject, filterFn, columns) {
+        try {
+            // Get fields for the specified object that are lookups
+            return this.getAppFieldsByAppObject(appObject, field => {
+                // Check if the field is a lookup type
+                const isLookup = field.LookUpDetails != null;
+                // Apply additional user filter if provided
+                return isLookup && (!filterFn || filterFn(field));
+            }, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjectLookupFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets data source queries with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered data source queries
+     *
+     * @example
+     * // Get all queries with a specific naming pattern
+     * const queries = metadataUtils.getDataSourceQueries(query => query.QueryName.includes('List'));
+     *
+     * // Get specific columns from all queries
+     * const queries = metadataUtils.getDataSourceQueries(
+     *   undefined,
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueries(filterFn, columns) {
+        try {
+            // Get all data source queries from all app objects
+            const allQueries = [];
+            Common.tabJson.AppObjects.forEach((obj) => {
+                if (obj.DataSourceQueries && obj.DataSourceQueries.length > 0) {
+                    allQueries.push(...obj.DataSourceQueries);
+                }
+            });
+            // Apply filter if provided
+            let filteredQueries = allQueries;
+            if (filterFn) {
+                filteredQueries = allQueries.filter(filterFn);
+            }
+            return this.formatResults(filteredQueries, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueries:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets data source queries for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of queries for the specified object
+     *
+     * @example
+     * // Get all queries for an object
+     * const queries = metadataUtils.getDataSourceQueriesByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c');
+     *
+     * // Get queries with specific pattern
+     * const filteredQueries = metadataUtils.getDataSourceQueriesByAppObject(
+     *   'TABD_Blueprint_SLASchemes',
+     *   query => query.QueryName.includes('List')
+     * );
+     */
+    getDataSourceQueriesByAppObject(appObject, filterFn, columns) {
+        try {
+            const filteredAppObject = this.getAppObjectDetails(appObject);
+            if (!filteredAppObject || !filteredAppObject.DataSourceQueries) {
+                return [];
+            }
+            let queries = filteredAppObject.DataSourceQueries;
+            // Apply filter if provided
+            if (filterFn) {
+                queries = queries.filter(filterFn);
+            }
+            return this.formatResults(queries, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjectQueries:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific Data Source Query by ID or Name
+     *
+     * @param query ID or Name of the data source query to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The data source query with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific query with all properties
+     * const query = metadataUtils.getDataSourceQueryDetails('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get specific columns from a query by name
+     * const query = metadataUtils.getDataSourceQueryDetails(
+     *   'Get_SLASchemes_List',
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueryDetails(query, columns) {
+        try {
+            return this.getDataSourceQueries(q => q.ID?.toLowerCase() === query?.toLowerCase() || q.QueryName === query, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQuery:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets fields from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of fields for the specified query with app field details
+     *
+     * @example
+     * // Get all fields for a query
+     * const queryFields = metadataUtils.getDataSourceQueryFields('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get fields for a query by name
+     * const queryFields = metadataUtils.getDataSourceQueryFields('Get_SLASchemes_List');
+     *
+     * // Get fields with filter and specific columns
+     * const fields = metadataUtils.getDataSourceQueryFields(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   field => field.FieldType === 1,
+     *   ['ID', 'AppFieldID', 'FieldType']
+     * );
+     */
+    getFieldsByDSQ(query, filterFn, columns) {
+        try {
+            // Find the query using our existing method
+            const dsQuery = this.getDataSourceQueryDetails(query);
+            if (!dsQuery || !dsQuery.Fields?.length) {
+                return [];
+            }
+            // Get enhanced fields with app field details
+            let queryFields = this.enhanceQueryFieldsWithAppFields(dsQuery);
+            // Apply filter if provided
+            if (filterFn) {
+                queryFields = queryFields.filter(filterFn);
+            }
+            return this.formatResults(queryFields, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueryFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Enhances query fields with their corresponding app field details
+     * @private
+     */
+    enhanceQueryFieldsWithAppFields(dsQuery) {
+        if (!dsQuery || !dsQuery.Fields?.length) {
+            return [];
+        }
+        // Find the parent app object
+        const parentAppObject = this.findParentAppObjectForQuery(dsQuery);
+        if (!parentAppObject) {
+            return dsQuery.Fields;
+        }
+        // Add app field details to each query field
+        return dsQuery.Fields.map((field) => {
+            const appField = this.findAppFieldById(parentAppObject, field.AppFieldID);
+            return {
+                ...field,
+                Field: appField || {}
+            };
+        });
+    }
+    /**
+     * Finds the parent app object that contains a specific data source query
+     * @private
+     */
+    findParentAppObjectForQuery(dsQuery) {
+        return this.getAppObjects(obj => obj.DataSourceQueries?.some((q) => q.ID?.toLowerCase() === dsQuery.ID?.toLowerCase() ||
+            q.QueryName === dsQuery.QueryName))[0];
+    }
+    /**
+     * Finds an app field by ID within a specific app object
+     * @private
+     */
+    findAppFieldById(appObject, fieldId) {
+        if (!appObject || !appObject.Fields?.length || !fieldId) {
+            return undefined;
+        }
+        return appObject.Fields.find((field) => field.ID?.toLowerCase() === fieldId?.toLowerCase());
+    }
+    /**
+     * Gets query parameters from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query parameters
+     * @param columns Optional columns to include in the result
+     * @returns Array of parameters for the specified query
+     *
+     * @example
+     * // Get all parameters for a query
+     * const queryParams = metadataUtils.getParametersByDSQ('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get all parameters for a query by name
+     * const queryParams = metadataUtils.getParametersByDSQ('Get_SLASchemes_List');
+     *
+     * // Get mandatory parameters only
+     * const mandatoryParams = metadataUtils.getParametersByDSQ(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   param => param.IsMandatory === true
+     * );
+     */
+    getParametersByDSQ(query, filterFn, columns) {
+        try {
+            // Find the query using our existing method
+            const dsQuery = this.getDataSourceQueryDetails(query);
+            if (!dsQuery || !dsQuery.Parameters?.length) {
+                return [];
+            }
+            let queryParameters = dsQuery.Parameters || [];
+            // Apply filter if provided
+            if (filterFn) {
+                queryParameters = queryParameters.filter(filterFn);
+            }
+            return this.formatResults(queryParameters, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueryParameters:', error);
+            return [];
+        }
+    }
+    /**
+    * Gets App Screens with filter criteria
+    *
+    * @param filterFn Optional filter function to apply to app screens
+    * @param columns Optional columns to include in the result
+    * @returns Array of filtered app screens
+    *
+    * @example
+    * // Get all system screens
+    * const systemScreens = metadataUtils.getAppScreens(screen => screen.IsSystemRecord === true);
+    *
+    * // Get specific columns from all screens
+    * const screens = metadataUtils.getAppScreens(
+    *   undefined,
+    *   ['ID', 'Name', 'ScreenType']
+    * );
+    */
+    getAppScreens(filterFn, columns) {
+        try {
+            let appScreens = Common.tabJson.AppScreens || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appScreens = appScreens.filter(filterFn);
+            }
+            return this.formatResults(appScreens, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppScreens:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific App Screen by ID or Name
+     *
+     * @param screen ID or Name of the app screen to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app screen with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific screen with all properties
+     * const screen = metadataUtils.getAppScreen('a5cd639e-31ba-4d33-8800-005a5248dfb2');
+     *
+     * // Get specific columns from a screen by name
+     * const screen = metadataUtils.getAppScreen(
+     *   'New Detail Role/Permission Appoject acess wise',
+     *   ['ID', 'Name', 'ScreenType']
+     * );
+     */
+    getAppScreen(screen, columns) {
+        try {
+            return this.getAppScreens(scr => scr.ID?.toLowerCase() === screen?.toLowerCase() || scr.Name === screen, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getAppScreen:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets App Menus with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app menus
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app menus
+     *
+     * @example
+     * // Get all top-level menus
+     * const topMenus = metadataUtils.getAppMenus(menu => !menu.ParentID);
+     *
+     * // Get specific columns from all menus
+     * const menus = metadataUtils.getAppMenus(
+     *   undefined,
+     *   ['ID', 'MenuName', 'DisplayName', 'ScreenID']
+     * );
+     */
+    getAppMenus(filterFn, columns) {
+        try {
+            let appMenus = Common.tabJson.AppMenus || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appMenus = appMenus.filter(filterFn);
+            }
+            return this.formatResults(appMenus, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppMenus:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets organization information with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to organizations
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered organizations
+     *
+     * @example
+     * // Get all organizations
+     * const orgs = metadataUtils.getOrgs();
+     *
+     * // Get organizations with specific subdomain pattern
+     * const specificOrgs = metadataUtils.getOrgs(
+     *   org => org.Subdomain?.includes('test')
+     * );
+     */
+    getOrgs(filterFn, columns) {
+        try {
+            let organizations = Common.tabJson.OrgInfos || [];
+            // Apply filter if provided
+            if (filterFn) {
+                organizations = organizations.filter(filterFn);
+            }
+            return this.formatResults(organizations, columns);
+        }
+        catch (error) {
+            console.error('Error in getOrganizations:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific organization by ID or Name
+     *
+     * @param organization ID or OrganizationName of the organization
+     * @param columns Optional columns to include in the result
+     * @returns The organization or null if not found
+     *
+     * @example
+     * // Get organization by ID
+     * const org = metadataUtils.getOrgInfoDetails('0ec3d0f1-b2ec-47b7-8305-b767d0e5ea63');
+     *
+     * // Get organization by name
+     * const org = metadataUtils.getOrgInfoDetails('SquadFocus');
+     */
+    getOrgInfoDetails(organization, columns) {
+        try {
+            return this.getOrgs(org => org.ID?.toLowerCase() === organization?.toLowerCase() ||
+                org.OrganizationName === organization ||
+                org.Subdomain === organization, columns)[0] || null;
+        }
+        catch (error) {
+            console.error('Error in getOrganization:', error);
+            return null;
+        }
+    }
+    static { this.ɵfac = function MetadataHelper_Factory(t) { return new (t || MetadataHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MetadataHelper, factory: MetadataHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetadataHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta-data.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/meta-data.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from \"@angular/core\";\nimport { MetadataEntityType, OrgInfo } from \"../../interfaces/schema.interface\";\nimport { Common } from \"../../constants/common\";\nimport { AppMenu, AppObject, AppScreen } from \"../../models/app-object.class\";\nimport { AppFields, DataSourceQueries, DataSourceQueries_Fields, Parameters } from \"../../models/data-source-queries.class\";\n\n/**\n   * MetadataUtils - Utility service for retrieving and manipulating application metadata\n   * \n   * This service provides methods to extract, filter, and format different parts of the\n   * application metadata, including objects, fields, screens, menus, etc.\n   */\n@Injectable({ providedIn: 'root' })\nexport class MetadataHelper {\n    // Helper method to consistently format results\n    private formatResults<T>(items: T[], columns?: string[]): any[] {\n        if (!columns || columns.length === 0) {\n            return items;\n        }\n\n        return items.map(item => {\n            const result: any = {};\n            columns.forEach(col => {\n                result[col] = (item as any)[col];\n            });\n            return result;\n        });\n    }\n\n    /**\n     * Search across all metadata for a term\n     * \n     * @param searchTerm Term to search for\n     * @param entityTypes Optional types of entities to search (if not provided, searches all)\n     * @returns Search results grouped by entity type\n     * \n     * @example\n     * // Search across all metadata\n     * const results = metadataUtils.searchAcrossMetadata('Blueprint');\n     * \n     * // Search only in app objects and screens\n     * const results = metadataUtils.searchAcrossMetadata(\n     *   'Role', \n     *   [MetadataEntityType.APP_OBJECTS, MetadataEntityType.APP_SCREENS]\n     * );\n     */\n    public searchAcrossMetadata(\n        searchTerm: string,\n        entityTypes?: MetadataEntityType[]\n    ): Record<string, any[]> {\n        try {\n            if (!searchTerm || searchTerm.trim() === '') {\n                return {};\n            }\n\n            const term = searchTerm.toLowerCase();\n            const results: Record<string, any[]> = {};\n\n            // If entityTypes not provided, search all entity types\n            const typesToSearch = entityTypes || Object.values(MetadataEntityType);\n\n            // Execute search for each entity type\n            if (typesToSearch.includes(MetadataEntityType.APP_OBJECTS)) {\n                results[MetadataEntityType.APP_OBJECTS] = this.searchAppObjects(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_FIELDS)) {\n                results[MetadataEntityType.APP_FIELDS] = this.searchAppFields(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.DATA_SOURCE_QUERIES)) {\n                results[MetadataEntityType.DATA_SOURCE_QUERIES] = this.searchDataSourceQueries(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_SCREENS)) {\n                results[MetadataEntityType.APP_SCREENS] = this.searchAppScreens(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_MENUS)) {\n                results[MetadataEntityType.APP_MENUS] = this.searchAppMenus(term);\n            }\n\n            return results;\n        } catch (error) {\n            console.error('Error in searchMetadata:', error);\n            return {};\n        }\n    }\n\n    /**\n     * Search for a term within App Objects\n     * @private\n     */\n    private searchAppObjects(term: string): any[] {\n        return this.getAppObjects(obj =>\n            this.containsTerm(obj.ObjectName, term) ||\n            this.containsTerm(obj.DisplayName, term) ||\n            this.containsTerm(obj.Description, term) ||\n            this.containsTerm(obj.SystemDBTableName, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Fields\n     * @private\n     */\n    private searchAppFields(term: string): any[] {\n        return this.getAppFields(field =>\n            this.containsTerm(field.FieldName, term) ||\n            this.containsTerm(field.DisplayName, term) ||\n            this.containsTerm(field.Description, term) ||\n            this.containsTerm(field.SystemDBFieldName, term)\n        );\n    }\n\n    /**\n     * Search for a term within Data Source Queries\n     * @private\n     */\n    private searchDataSourceQueries(term: string): any[] {\n        return this.getDataSourceQueries(query =>\n            this.containsTerm(query.QueryName, term) ||\n            this.containsTerm(query.DisplayName, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Screens\n     * @private\n     */\n    private searchAppScreens(term: string): any[] {\n        return this.getAppScreens(screen =>\n            this.containsTerm(screen.Name, term) ||\n            this.containsTerm(screen.Description, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Menus\n     * @private\n     */\n    private searchAppMenus(term: string): any[] {\n        return this.getAppMenus(menu =>\n            this.containsTerm(menu.MenuName, term) ||\n            this.containsTerm(menu.DisplayName, term)\n        );\n    }\n\n    /**\n     * Helper method to check if a string contains a search term\n     * @private\n     */\n    private containsTerm(value: string | undefined | null, term: string): boolean {\n        return !!value && value.toLowerCase().includes(term);\n    }\n\n    /**\n     * Gets App Objects based on filter criteria\n     * \n     * @param filterFn Optional filter function to apply to app objects\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered app objects\n     * \n     * @example\n     * // Get all system app objects\n     * const systemObjects = metadataUtils.getAppObjects(obj => obj.IsSystem === true);\n     * \n     * // Get specific columns from non-deprecated objects\n     * const objects = metadataUtils.getAppObjects(\n     *   obj => !obj.IsDeprecated, \n     *   ['ID', 'DisplayName', 'ObjectName']\n     * );\n     */\n    public getAppObjects(filterFn?: ((value: AppObject) => boolean), columns?: string[]): any[] {\n        try {\n            let appObjects = Common.tabJson.AppObjects || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appObjects = appObjects.filter(filterFn);\n            }\n\n\n            // Return all object data if no columns specified\n            return this.formatResults(appObjects, columns);\n\n        } catch (error) {\n            console.error('Error in getAppObjects:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific App Object by ID or Name\n     * \n     * @param appObject ID or Name of the app object to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The app object with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific app object with all properties\n     * const appObj = metadataUtils.getAppObjectDetails('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');\n     * \n     * // Get specific columns from an app object\n     * const appObj = metadataUtils.getAppObjectDetails(\n     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c', \n     *   ['ID', 'DisplayName', 'ObjectName']\n     * );\n     */\n    public getAppObjectDetails(appObject: string, columns?: string[]): any {\n        try {\n            return this.getAppObjects(obj => obj.ID?.toLowerCase() === appObject?.toLowerCase() || obj.ObjectName === appObject, columns)?.[0] ?? null;\n\n        } catch (error) {\n            console.error('Error in getAppObjectById:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets all fields across all app objects with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to fields\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered fields\n     * \n     * @example\n     * // Get all required fields across all objects\n     * const requiredFields = metadataUtils.getAppFields(field => field.IsRequired === true);\n     * \n     * // Get specific columns from searchable fields\n     * const fields = metadataUtils.getAppFields(\n     *   field => field.IsSearchable === true, \n     *   ['ID', 'DisplayName', 'FieldName']\n     * );\n     */\n    public getAppFields(filterFn?: ((value: AppFields) => boolean), columns?: string[]): any[] {\n        try {\n            // Get all fields from all app objects\n            const allFields: AppFields[] = [];\n            Common.tabJson.AppObjects.forEach((obj: any) => {\n                allFields.push(...obj.Fields);\n            });\n\n            // Apply filter if provided\n            let filteredFields = allFields;\n            if (filterFn) {\n                filteredFields = allFields.filter(filterFn);\n            }\n\n            // Return all field data if no columns specified\n            return this.formatResults(filteredFields, columns);\n        } catch (error) {\n            console.error('Error in getAppFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets fields for a specific app object\n     * \n     * @param appObject ID or Name of the app object\n     * @param filterFn Optional filter function for fields\n     * @returns Array of fields for the specified object\n     * \n     * @example\n     * // Get all fields for an object\n     * const fields = metadataUtils.getAppFieldsByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');\n     * \n     * // Get only required fields\n     * const requiredFields = metadataUtils.getAppFieldsByAppObject(\n     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',\n     *   field => field.IsRequired === true\n     * );\n     */\n    public getAppFieldsByAppObject(\n        appObject: string,\n        filterFn?: ((value: AppFields, index: number, array: AppFields[]) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            const filteredAppObject: any = this.getAppObjectDetails(appObject);\n            if (!filteredAppObject) {\n                return [];\n            }\n\n            let fields = filteredAppObject.Fields || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                fields = fields.filter(filterFn);\n            }\n\n            return this.formatResults(fields, columns);\n        } catch (error) {\n            console.error('Error in getAppFieldById:', error);\n            return [];\n        }\n    }\n\n    /**\n    * Gets lookup fields for a specific app object\n    * \n    * @param appObject ID or Name of the app object\n    * @param filterFn Optional filter function for lookup fields\n    * @param columns Optional columns to include in the result\n    * @returns Array of lookup fields for the specified object\n    * \n    * @example\n    * // Get all lookup fields for an object\n    * const lookupFields = metadataUtils.getLookupFieldsByAppObject('TABD_Blueprint_SLASchemes');\n    * \n    * // Get specific lookup fields\n    * const fields = metadataUtils.getLookupFieldsByAppObject(\n    *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',\n    *   field => field.IsRequired === true\n    * );\n    */\n    public getLookupFieldsByAppObject(\n        appObject: string,\n        filterFn?: ((value: AppFields) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Get fields for the specified object that are lookups\n            return this.getAppFieldsByAppObject(\n                appObject,\n                field => {\n                    // Check if the field is a lookup type\n                    const isLookup = field.LookUpDetails != null;\n\n                    // Apply additional user filter if provided\n                    return isLookup && (!filterFn || filterFn(field));\n                },\n                columns\n            );\n        } catch (error) {\n            console.error('Error in getAppObjectLookupFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets data source queries with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to queries\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered data source queries\n     * \n     * @example\n     * // Get all queries with a specific naming pattern\n     * const queries = metadataUtils.getDataSourceQueries(query => query.QueryName.includes('List'));\n     * \n     * // Get specific columns from all queries\n     * const queries = metadataUtils.getDataSourceQueries(\n     *   undefined, \n     *   ['ID', 'QueryName', 'DisplayName']\n     * );\n     */\n    public getDataSourceQueries(filterFn?: ((value: DataSourceQueries) => boolean), columns?: string[]): any[] {\n        try {\n            // Get all data source queries from all app objects\n            const allQueries: DataSourceQueries[] = [];\n            Common.tabJson.AppObjects.forEach((obj: any) => {\n                if (obj.DataSourceQueries && obj.DataSourceQueries.length > 0) {\n                    allQueries.push(...obj.DataSourceQueries);\n                }\n            });\n\n            // Apply filter if provided\n            let filteredQueries = allQueries;\n            if (filterFn) {\n                filteredQueries = allQueries.filter(filterFn);\n            }\n\n            return this.formatResults(filteredQueries, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueries:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets data source queries for a specific app object\n     * \n     * @param appObject ID or Name of the app object\n     * @param filterFn Optional filter function for queries\n     * @param columns Optional columns to include in the result\n     * @returns Array of queries for the specified object\n     * \n     * @example\n     * // Get all queries for an object\n     * const queries = metadataUtils.getDataSourceQueriesByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c');\n     * \n     * // Get queries with specific pattern\n     * const filteredQueries = metadataUtils.getDataSourceQueriesByAppObject(\n     *   'TABD_Blueprint_SLASchemes',\n     *   query => query.QueryName.includes('List')\n     * );\n     */\n    public getDataSourceQueriesByAppObject(\n        appObject: string,\n        filterFn?: ((value: DataSourceQueries) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            const filteredAppObject: any = this.getAppObjectDetails(appObject);\n            if (!filteredAppObject || !filteredAppObject.DataSourceQueries) {\n                return [];\n            }\n\n            let queries = filteredAppObject.DataSourceQueries;\n\n            // Apply filter if provided\n            if (filterFn) {\n                queries = queries.filter(filterFn);\n            }\n\n            return this.formatResults(queries, columns);\n        } catch (error) {\n            console.error('Error in getAppObjectQueries:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific Data Source Query by ID or Name\n     * \n     * @param query ID or Name of the data source query to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The data source query with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific query with all properties\n     * const query = metadataUtils.getDataSourceQueryDetails('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get specific columns from a query by name\n     * const query = metadataUtils.getDataSourceQueryDetails(\n     *   'Get_SLASchemes_List',\n     *   ['ID', 'QueryName', 'DisplayName']\n     * );\n     */\n    public getDataSourceQueryDetails(query: string, columns?: string[]): any {\n        try {\n            return this.getDataSourceQueries(q =>\n                q.ID?.toLowerCase() === query?.toLowerCase() || q.QueryName === query,\n                columns\n            )?.[0] ?? null;\n        } catch (error) {\n            console.error('Error in getDataSourceQuery:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets fields from a data source query\n     * \n     * @param query ID or Name of the data source query\n     * @param filterFn Optional filter function for query fields\n     * @param columns Optional columns to include in the result\n     * @returns Array of fields for the specified query with app field details\n     * \n     * @example\n     * // Get all fields for a query\n     * const queryFields = metadataUtils.getDataSourceQueryFields('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get fields for a query by name\n     * const queryFields = metadataUtils.getDataSourceQueryFields('Get_SLASchemes_List');\n     * \n     * // Get fields with filter and specific columns\n     * const fields = metadataUtils.getDataSourceQueryFields(\n     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',\n     *   field => field.FieldType === 1,\n     *   ['ID', 'AppFieldID', 'FieldType']\n     * );\n     */\n    public getFieldsByDSQ(\n        query: string,\n        filterFn?: ((value: DataSourceQueries_Fields) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Find the query using our existing method\n            const dsQuery = this.getDataSourceQueryDetails(query);\n            if (!dsQuery || !dsQuery.Fields?.length) {\n                return [];\n            }\n\n            // Get enhanced fields with app field details\n            let queryFields = this.enhanceQueryFieldsWithAppFields(dsQuery);\n\n            // Apply filter if provided\n            if (filterFn) {\n                queryFields = queryFields.filter(filterFn);\n            }\n\n            return this.formatResults(queryFields, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueryFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Enhances query fields with their corresponding app field details\n     * @private\n     */\n    private enhanceQueryFieldsWithAppFields(dsQuery: DataSourceQueries): any[] {\n        if (!dsQuery || !dsQuery.Fields?.length) {\n            return [];\n        }\n\n        // Find the parent app object\n        const parentAppObject = this.findParentAppObjectForQuery(dsQuery);\n        if (!parentAppObject) {\n            return dsQuery.Fields;\n        }\n\n        // Add app field details to each query field\n        return dsQuery.Fields.map((field: any) => {\n            const appField = this.findAppFieldById(parentAppObject, field.AppFieldID);\n            return {\n                ...field,\n                Field: appField || {}\n            };\n        });\n    }\n\n    /**\n     * Finds the parent app object that contains a specific data source query\n     * @private\n     */\n    private findParentAppObjectForQuery(dsQuery: DataSourceQueries): AppObject | undefined {\n        return this.getAppObjects(obj =>\n            obj.DataSourceQueries?.some((q: any) =>\n                q.ID?.toLowerCase() === dsQuery.ID?.toLowerCase() ||\n                q.QueryName === dsQuery.QueryName\n            )\n        )[0];\n    }\n\n    /**\n     * Finds an app field by ID within a specific app object\n     * @private\n     */\n    private findAppFieldById(appObject: AppObject, fieldId: string): any {\n        if (!appObject || !appObject.Fields?.length || !fieldId) {\n            return undefined;\n        }\n\n        return appObject.Fields.find(\n            (field: any) => field.ID?.toLowerCase() === fieldId?.toLowerCase()\n        );\n    }\n\n    /**\n     * Gets query parameters from a data source query\n     * \n     * @param query ID or Name of the data source query\n     * @param filterFn Optional filter function for query parameters\n     * @param columns Optional columns to include in the result\n     * @returns Array of parameters for the specified query\n     * \n     * @example\n     * // Get all parameters for a query\n     * const queryParams = metadataUtils.getParametersByDSQ('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get all parameters for a query by name\n     * const queryParams = metadataUtils.getParametersByDSQ('Get_SLASchemes_List');\n     * \n     * // Get mandatory parameters only\n     * const mandatoryParams = metadataUtils.getParametersByDSQ(\n     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',\n     *   param => param.IsMandatory === true\n     * );\n     */\n    public getParametersByDSQ(\n        query: string,\n        filterFn?: ((value: Parameters) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Find the query using our existing method\n            const dsQuery = this.getDataSourceQueryDetails(query);\n            if (!dsQuery || !dsQuery.Parameters?.length) {\n                return [];\n            }\n\n            let queryParameters: Parameters[] = dsQuery.Parameters || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                queryParameters = queryParameters.filter(filterFn);\n            }\n\n            return this.formatResults(queryParameters, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueryParameters:', error);\n            return [];\n        }\n    }\n\n    /**\n    * Gets App Screens with filter criteria\n    * \n    * @param filterFn Optional filter function to apply to app screens\n    * @param columns Optional columns to include in the result\n    * @returns Array of filtered app screens\n    * \n    * @example\n    * // Get all system screens\n    * const systemScreens = metadataUtils.getAppScreens(screen => screen.IsSystemRecord === true);\n    * \n    * // Get specific columns from all screens\n    * const screens = metadataUtils.getAppScreens(\n    *   undefined, \n    *   ['ID', 'Name', 'ScreenType']\n    * );\n    */\n    public getAppScreens(filterFn?: ((value: AppScreen) => boolean), columns?: string[]): any[] {\n        try {\n            let appScreens = Common.tabJson.AppScreens || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appScreens = appScreens.filter(filterFn);\n            }\n\n            return this.formatResults(appScreens, columns);\n        } catch (error) {\n            console.error('Error in getAppScreens:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific App Screen by ID or Name\n     * \n     * @param screen ID or Name of the app screen to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The app screen with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific screen with all properties\n     * const screen = metadataUtils.getAppScreen('a5cd639e-31ba-4d33-8800-005a5248dfb2');\n     * \n     * // Get specific columns from a screen by name\n     * const screen = metadataUtils.getAppScreen(\n     *   'New Detail Role/Permission Appoject acess wise',\n     *   ['ID', 'Name', 'ScreenType']\n     * );\n     */\n    public getAppScreen(screen: string, columns?: string[]): any {\n        try {\n            return this.getAppScreens(scr =>\n                scr.ID?.toLowerCase() === screen?.toLowerCase() || scr.Name === screen,\n                columns\n            )?.[0] ?? null;\n        } catch (error) {\n            console.error('Error in getAppScreen:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets App Menus with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to app menus\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered app menus\n     * \n     * @example\n     * // Get all top-level menus\n     * const topMenus = metadataUtils.getAppMenus(menu => !menu.ParentID);\n     * \n     * // Get specific columns from all menus\n     * const menus = metadataUtils.getAppMenus(\n     *   undefined, \n     *   ['ID', 'MenuName', 'DisplayName', 'ScreenID']\n     * );\n     */\n    public getAppMenus(filterFn?: ((value: AppMenu) => boolean), columns?: string[]): any[] {\n        try {\n            let appMenus = Common.tabJson.AppMenus || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appMenus = appMenus.filter(filterFn);\n            }\n\n            return this.formatResults(appMenus, columns);\n        } catch (error) {\n            console.error('Error in getAppMenus:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets organization information with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to organizations\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered organizations\n     * \n     * @example\n     * // Get all organizations\n     * const orgs = metadataUtils.getOrgs();\n     * \n     * // Get organizations with specific subdomain pattern\n     * const specificOrgs = metadataUtils.getOrgs(\n     *   org => org.Subdomain?.includes('test')\n     * );\n     */\n    public getOrgs(filterFn?: ((value: OrgInfo) => boolean), columns?: string[]): any[] {\n        try {\n            let organizations = Common.tabJson.OrgInfos || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                organizations = organizations.filter(filterFn);\n            }\n\n            return this.formatResults(organizations, columns);\n        } catch (error) {\n            console.error('Error in getOrganizations:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific organization by ID or Name\n     * \n     * @param organization ID or OrganizationName of the organization\n     * @param columns Optional columns to include in the result\n     * @returns The organization or null if not found\n     * \n     * @example\n     * // Get organization by ID\n     * const org = metadataUtils.getOrgInfoDetails('0ec3d0f1-b2ec-47b7-8305-b767d0e5ea63');\n     * \n     * // Get organization by name\n     * const org = metadataUtils.getOrgInfoDetails('SquadFocus');\n     */\n    public getOrgInfoDetails(organization: string, columns?: string[]): any {\n        try {\n            return this.getOrgs(org =>\n                org.ID?.toLowerCase() === organization?.toLowerCase() ||\n                org.OrganizationName === organization ||\n                org.Subdomain === organization,\n                columns\n            )[0] || null;\n        } catch (error) {\n            console.error('Error in getOrganization:', error);\n            return null;\n        }\n    }\n}"]}