@techextensor/tab-core-utility 2.2.132 → 2.2.134

package/esm2022/lib/tab-core-utility/app/interfaces/schema.interface.mjs

@@ -4,6 +4,5 @@ export var MetadataEntityType;
     MetadataEntityType["APP_FIELDS"] = "AppFields";
     MetadataEntityType["DATA_SOURCE_QUERIES"] = "DataSourceQueries";
     MetadataEntityType["APP_SCREENS"] = "AppScreens";
-    MetadataEntityType["APP_MENUS"] = "AppMenus";
 })(MetadataEntityType || (MetadataEntityType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sQ0FBTixJQUFZLGtCQU1YO0FBTkQsV0FBWSxrQkFBa0I7SUFDNUIsZ0RBQTBCLENBQUE7SUFDMUIsOENBQXdCLENBQUE7SUFDeEIsK0RBQXlDLENBQUE7SUFDekMsZ0RBQTBCLENBQUE7SUFDMUIsNENBQXNCLENBQUE7QUFDeEIsQ0FBQyxFQU5XLGtCQUFrQixLQUFsQixrQkFBa0IsUUFNN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogc3RyaW5nXG4gIFN0YXR1c0NvZGU6IHN0cmluZ1xuICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxuICBUb3RhbEV4ZWN1dGlvblRpbWU6IG51bWJlclxuICBMb2c6IGFueVtdXG4gIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvIHtcbiAgSUQ6IHN0cmluZztcbiAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nO1xuICBQcmltYXJ5Q29udGFjdDogYW55O1xuICBBZGRyZXNzOiBhbnk7XG4gIExvY2FsZVNldHRpbmdzOiBzdHJpbmcgfCBudWxsO1xuICBTdWJkb21haW46IHN0cmluZztcbiAgVGVuYW50Q29kZTogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGVudW0gTWV0YWRhdGFFbnRpdHlUeXBlIHtcbiAgQVBQX09CSkVDVFMgPSAnQXBwT2JqZWN0cycsXG4gIEFQUF9GSUVMRFMgPSAnQXBwRmllbGRzJyxcbiAgREFUQV9TT1VSQ0VfUVVFUklFUyA9ICdEYXRhU291cmNlUXVlcmllcycsXG4gIEFQUF9TQ1JFRU5TID0gJ0FwcFNjcmVlbnMnLFxuICBBUFBfTUVOVVMgPSAnQXBwTWVudXMnXG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sQ0FBTixJQUFZLGtCQUtYO0FBTEQsV0FBWSxrQkFBa0I7SUFDNUIsZ0RBQTBCLENBQUE7SUFDMUIsOENBQXdCLENBQUE7SUFDeEIsK0RBQXlDLENBQUE7SUFDekMsZ0RBQTBCLENBQUE7QUFDNUIsQ0FBQyxFQUxXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFLN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogc3RyaW5nXG4gIFN0YXR1c0NvZGU6IHN0cmluZ1xuICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxuICBUb3RhbEV4ZWN1dGlvblRpbWU6IG51bWJlclxuICBMb2c6IGFueVtdXG4gIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvIHtcbiAgSUQ6IHN0cmluZztcbiAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nO1xuICBQcmltYXJ5Q29udGFjdDogYW55O1xuICBBZGRyZXNzOiBhbnk7XG4gIExvY2FsZVNldHRpbmdzOiBzdHJpbmcgfCBudWxsO1xuICBTdWJkb21haW46IHN0cmluZztcbiAgVGVuYW50Q29kZTogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGVudW0gTWV0YWRhdGFFbnRpdHlUeXBlIHtcbiAgQVBQX09CSkVDVFMgPSAnQXBwT2JqZWN0cycsXG4gIEFQUF9GSUVMRFMgPSAnQXBwRmllbGRzJyxcbiAgREFUQV9TT1VSQ0VfUVVFUklFUyA9ICdEYXRhU291cmNlUXVlcmllcycsXG4gIEFQUF9TQ1JFRU5TID0gJ0FwcFNjcmVlbnMnXG59Il19

package/esm2022/lib/tab-core-utility/app/models/app-field.model.mjs

@@ -0,0 +1,72 @@
+import { DataTypes } from "../enums/controllers.enum";
+export class AppFieldModel {
+    constructor(raw) {
+        this.raw = raw;
+        this.ID = raw.ID;
+        this.ObjectID = raw.ObjectID ?? null;
+        this.ObjectID_Tosave = raw.ObjectID_Tosave;
+        this.FieldName = raw.FieldName;
+        this.DisplayName = raw.DisplayName;
+        this.Description = raw.Description ?? '';
+        this.FieldType = raw.FieldType;
+        this.CreationType = raw.CreationType;
+        this.FieldBase = raw.FieldBase;
+        this.BaseField = raw.BaseField ?? null;
+        this.IsRequired = !!raw.IsRequired;
+        this.IsUnique = !!raw.IsUnique;
+        this.IsSearchable = !!raw.IsSearchable;
+        this.IsUpdatable = !!raw.IsUpdatable;
+        this.IsConfidential = !!raw.IsConfidential;
+        this.SystemDBFieldName = raw.SystemDBFieldName;
+        this.IsSystem = !!raw.IsSystem;
+        this.IsVisible = !!raw.IsVisible;
+        this.IsPrimaryKey = !!raw.IsPrimaryKey;
+        this.IsDeprecated = !!raw.IsDeprecated;
+        this.IsDisplayField = !!raw.IsDisplayField;
+        this.LookUpDetails = raw.LookUpDetails ?? null;
+        this.IsLookup = !!raw.LookUpDetails;
+        this.AccessList = raw.AccessList ?? [];
+        this.Data = raw.Data ?? null;
+        this.FieldValidatorConfiguration = raw.FieldValidatorConfiguration ?? {};
+        this.FieldConfiguration = this.parseFieldConfiguration(raw.FieldConfiguration);
+    }
+    parseFieldConfiguration(config) {
+        try {
+            return typeof config === 'string' ? JSON.parse(config) : (config ?? {});
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Gets the data type name of the field as a string.
+     * The data type name is obtained from the DataTypes enum.
+     * @returns {string} The data type name.
+     */
+    get dataTypeName() {
+        return DataTypes[this.FieldType?.DataType] ?? '';
+    }
+    /**
+     * Searches for the given search term in the properties of the current AppFieldModel instance.
+     * The search is case-insensitive and is performed on the following properties:
+     * - ID
+     * - FieldName
+     * - DisplayName
+     * - SystemDBFieldName
+     * @param {string} term The search term.
+     * @returns {boolean} Whether the search term is present in any of the properties.
+     */
+    search(term) {
+        const searchTerm = term.toLowerCase();
+        return [this.ID, this.FieldName, this.DisplayName, this.SystemDBFieldName]
+            .some(val => val === searchTerm || val?.toLowerCase().includes(searchTerm));
+    }
+    /**
+     * Converts the AppFieldModel instance to a JSON representation.
+     * @returns {any} The raw data of the instance.
+     */
+    toJSON() {
+        return this.raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-field.model.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/models/app-field.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataTypes } from \"../enums/controllers.enum\";\nimport { DataSourceQueryFieldType, ObjectCreationType } from \"../enums/dsq.enum\";\nimport { FieldAccess, FieldType, LookUpDetails } from \"./data-source-queries.class\";\n\nexport class AppFieldModel {\n  readonly ID: string;\n  readonly ObjectID: string | null;\n  readonly ObjectID_Tosave: string;\n  readonly FieldName: string;\n  readonly DisplayName: string;\n  readonly Description: string;\n  readonly FieldType: FieldType;\n  readonly CreationType: ObjectCreationType;\n  readonly FieldBase: DataSourceQueryFieldType;\n  readonly IsRequired: boolean;\n  readonly IsUnique: boolean;\n  readonly BaseField: string | null;\n  readonly IsSearchable: boolean;\n  readonly IsUpdatable: boolean;\n  readonly IsConfidential: boolean;\n  readonly SystemDBFieldName: string;\n  readonly IsSystem: boolean;\n  readonly IsVisible: boolean;\n  readonly IsPrimaryKey: boolean;\n  readonly IsDeprecated: boolean;\n  readonly IsDisplayField: boolean;\n  readonly LookUpDetails: LookUpDetails;\n  readonly IsLookup: boolean;\n  readonly AccessList: FieldAccess[];\n  readonly Data: string | null;\n  readonly FieldConfiguration: any;\n  readonly FieldValidatorConfiguration: any;\n\n  constructor(private readonly raw: any) {\n    this.ID = raw.ID;\n    this.ObjectID = raw.ObjectID ?? null;\n    this.ObjectID_Tosave = raw.ObjectID_Tosave;\n    this.FieldName = raw.FieldName;\n    this.DisplayName = raw.DisplayName;\n    this.Description = raw.Description ?? '';\n    this.FieldType = raw.FieldType;\n    this.CreationType = raw.CreationType;\n    this.FieldBase = raw.FieldBase;\n    this.BaseField = raw.BaseField ?? null;\n    this.IsRequired = !!raw.IsRequired;\n    this.IsUnique = !!raw.IsUnique;\n    this.IsSearchable = !!raw.IsSearchable;\n    this.IsUpdatable = !!raw.IsUpdatable;\n    this.IsConfidential = !!raw.IsConfidential;\n    this.SystemDBFieldName = raw.SystemDBFieldName;\n    this.IsSystem = !!raw.IsSystem;\n    this.IsVisible = !!raw.IsVisible;\n    this.IsPrimaryKey = !!raw.IsPrimaryKey;\n    this.IsDeprecated = !!raw.IsDeprecated;\n    this.IsDisplayField = !!raw.IsDisplayField;\n    this.LookUpDetails = raw.LookUpDetails ?? null;\n    this.IsLookup = !!raw.LookUpDetails;\n    this.AccessList = raw.AccessList ?? [];\n    this.Data = raw.Data ?? null;\n    this.FieldValidatorConfiguration = raw.FieldValidatorConfiguration ?? {};\n    this.FieldConfiguration = this.parseFieldConfiguration(raw.FieldConfiguration);\n  }\n\n  private parseFieldConfiguration(config: any): any {\n    try {\n      return typeof config === 'string' ? JSON.parse(config) : (config ?? {});\n    } catch {\n      return {};\n    }\n  }\n\n  /**\n   * Gets the data type name of the field as a string.\n   * The data type name is obtained from the DataTypes enum.\n   * @returns {string} The data type name.\n   */\n  get dataTypeName(): string {\n    return DataTypes[this.FieldType?.DataType] ?? '';\n  }\n\n  /**\n   * Searches for the given search term in the properties of the current AppFieldModel instance.\n   * The search is case-insensitive and is performed on the following properties:\n   * - ID\n   * - FieldName\n   * - DisplayName\n   * - SystemDBFieldName\n   * @param {string} term The search term.\n   * @returns {boolean} Whether the search term is present in any of the properties.\n   */\n  search(term: string): boolean {\n    const searchTerm = term.toLowerCase();\n    return [this.ID, this.FieldName, this.DisplayName, this.SystemDBFieldName]\n      .some(val => val === searchTerm || val?.toLowerCase().includes(searchTerm));\n  }\n\n  /**\n   * Converts the AppFieldModel instance to a JSON representation.\n   * @returns {any} The raw data of the instance.\n   */\n  toJSON(): any {\n    return this.raw;\n  }\n}"]}

package/esm2022/lib/tab-core-utility/app/models/app-object.class.mjs

@@ -27,4 +27,4 @@ export class AppMenu {
 }
 export class AppScreen {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/models/app-object.model.mjs

@@ -0,0 +1,186 @@
+import { AppFieldModel } from './app-field.model';
+import { DataSourceQueryModel } from './data-source-query.model';
+export class AppObjectModel {
+    constructor(raw) {
+        this.raw = raw;
+        // Cache maps
+        this.fieldMap = new Map();
+        this.dsqMap = new Map();
+        this.allFields = [];
+        this.allDSQs = [];
+        this.ID = raw?.ID;
+        this.ObjectName = raw?.ObjectName;
+        this.DisplayName = raw?.DisplayName;
+        this.Description = raw?.Description;
+        this.SystemDBTableName = raw?.SystemDBTableName;
+        this.IsSystem = raw?.IsSystem;
+        this.IsVisible = raw?.IsVisible;
+        this.IsDeprecated = raw?.IsDeprecated;
+        this.IsSupportBluePrint = raw?.IsSupportBluePrint;
+        this.IsLocationTracking = raw?.IsLocationTracking;
+        this.ObjectType = raw?.ObjectType;
+        this.DeploymentStatus = raw?.DeploymentStatus;
+        this.CreationType = raw?.CreationType;
+        this.AllowVersioning = raw?.AllowVersioning;
+        this.EnableTracking = raw?.EnableTracking;
+        this.AllowSearchable = raw?.AllowSearchable;
+        this.AllowReports = raw?.AllowReports;
+        this.AllowActivities = raw?.AllowActivities;
+        this.AllowSharing = raw?.AllowSharing;
+        this.AllowSoftDelete = raw?.AllowSoftDelete;
+        this.IsReplicationNeeded = raw?.IsReplicationNeeded;
+        this.IsCacheEnable = raw?.IsCacheEnable;
+        this.CacheTtl = raw?.CacheTtl;
+        this.AppObjectConfiguration = raw?.AppObjectConfiguration;
+        this.CRUDAppObjectId = raw?.CRUDAppObjectId;
+        this.ConnectionId = raw?.ConnectionId;
+        this.IsSupportLayout = raw?.IsSupportLayout;
+        this.AccessList = raw?.AccessList;
+        this.Resources = raw?.Resources;
+        try {
+            this.parsedAppObjectConfiguration = JSON.parse(this.AppObjectConfiguration || '{}');
+        }
+        catch (e) {
+            console.warn('Invalid AppObjectConfiguration JSON', e);
+            this.parsedAppObjectConfiguration = {};
+        }
+    }
+    /**
+     * Returns all fields associated with this AppObject. The fields are cached so that subsequent calls
+     * are faster. The cache is stored in a map by ID.
+     *
+     * @returns {AppFieldModel[]} An array of AppFieldModel objects.
+     */
+    fields() {
+        if (!this.allFields?.length) {
+            this.allFields = (this.raw?.Fields ?? []).map((field) => {
+                const model = new AppFieldModel(field);
+                // Cache the field in a map by ID
+                this.fieldMap.set(field?.ID, model);
+                return model;
+            });
+        }
+        return this.allFields;
+    }
+    /**
+     * Retrieves a field by its ID or name.
+     * If the field is cached, it returns it from the cache.
+     * Otherwise, it searches through all fields.
+     *
+     * @param {string} idOrName - The ID or name of the field to retrieve.
+     * @returns {AppFieldModel | undefined} - The field model if found, otherwise undefined.
+     */
+    field(idOrName) {
+        // Ensure all fields are loaded and cached
+        this.fields();
+        // Check if the field is available in the cache map
+        if (this.fieldMap.has(idOrName)) {
+            return this.fieldMap.get(idOrName);
+        }
+        // Convert the idOrName to lowercase for case-insensitive search
+        const idLower = idOrName.toLowerCase();
+        // Find the field by matching ID or name, case-insensitively
+        return this.allFields?.find(f => f.FieldName?.toLowerCase() === idLower || f.DisplayName?.toLowerCase() === idLower);
+    }
+    /**
+     * Retrieves all fields of the app object that are lookup fields.
+     * A lookup field is a field that has a relationship with another field.
+     * It is used to perform lookups, such as retrieving a list of values
+     * from a related field.
+     *
+     * @returns {AppFieldModel[]} - An array of AppFieldModel objects that are lookup fields.
+     */
+    lookupFields() {
+        return this.fields().filter(field => field.IsLookup);
+    }
+    /**
+     * Finds and returns the fields for the app object that satisfy the given filter function.
+     * The filter function is called with each field as an argument, and should return true if the field
+     * should be included in the result.
+     * @param {function} filterFn The filter function to apply to the fields.
+     * @returns {AppFieldModel[]} The array of fields that satisfy the filter function.
+     */
+    findFields(filterFn) {
+        return this.fields().filter(filterFn);
+    }
+    /**
+     * Retrieves all data source queries associated with this AppObject.
+     * The queries are cached for faster subsequent access. The cache is stored in a map by ID, QueryName, and DisplayName.
+     *
+     * @returns {DataSourceQueryModel[]} An array of DataSourceQueryModel objects.
+     */
+    dataSourceQueries() {
+        // Check if allDSQs is empty or undefined
+        if (!this.allDSQs?.length) {
+            // Map the raw DataSourceQueries to DataSourceQueryModel instances
+            this.allDSQs = (this.raw?.DataSourceQueries ?? []).map((dsq) => {
+                const model = new DataSourceQueryModel(dsq, this);
+                // Cache the DataSourceQuery in a map by ID, QueryName, and DisplayName
+                this.dsqMap.set(dsq?.ID, model);
+                this.dsqMap.set(dsq?.QueryName, model);
+                this.dsqMap.set(dsq?.DisplayName, model);
+                return model;
+            });
+        }
+        return this.allDSQs;
+    }
+    /**
+     * Retrieves a data source query by its ID or name.
+     * If the query is cached, it returns it from the cache.
+     * Otherwise, it searches through all data source queries.
+     *
+     * @param {string} idOrName - The ID or name of the data source query to retrieve.
+     * @returns {DataSourceQueryModel | undefined} - The data source query model if found, otherwise undefined.
+     */
+    dataSourceQuery(idOrName) {
+        // Ensure all data source queries are loaded and cached
+        this.dataSourceQueries();
+        // Check if the data source query is available in the cache map
+        if (this.dsqMap.has(idOrName)) {
+            return this.dsqMap.get(idOrName);
+        }
+        // Convert the idOrName to lowercase for case-insensitive search
+        const idLower = idOrName.toLowerCase();
+        // Find the data source query by matching QueryName or DisplayName, case-insensitively
+        return this.allDSQs?.find(dsq => dsq.QueryName?.toLowerCase() === idLower || dsq.DisplayName?.toLowerCase() === idLower);
+    }
+    /**
+     * Finds and returns the data source queries that satisfy the given filter function.
+     * The filter function is called with each data source query as an argument.
+     * If the filter function returns true, the data source query is included in the result.
+     *
+     * @param {function} filterFn - The filter function to apply to the data source queries.
+     * @returns {DataSourceQueryModel[]} - The array of data source queries that satisfy the filter function.
+     */
+    findDataSourceQueries(filterFn) {
+        return this.dataSourceQueries().filter(filterFn);
+    }
+    /**
+     * Searches for the given term in the fields and data source queries of this AppObject.
+     * The search is case-insensitive and performed on the following fields:
+     *   - Field name and description
+     *   - Data source query name, display name, and description
+     *
+     * @param {string} term - The search term to search for.
+     * @returns {{ fields: AppFieldModel[]; dsqs: DataSourceQueryModel[] }} - An object with the search results.
+     *   The `fields` property contains an array of AppFieldModel objects that match the search term.
+     *   The `dsqs` property contains an array of DataSourceQueryModel objects that match the search term.
+     */
+    search(term) {
+        // Search for the term in the fields
+        const fields = this.fields().filter(field => field.search(term));
+        // Search for the term in the data source queries
+        const dsqs = this.dataSourceQueries().filter(dsq => dsq.search(term));
+        // Return the search results
+        return { fields, dsqs };
+    }
+    /**
+     * Converts the current object to a JSON object.
+     *
+     * @returns {any} The raw data as a JSON object.
+     */
+    toJSON() {
+        return this.raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-object.model.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/models/app-object.model.ts"],"names":[],"mappings":"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","sourcesContent":["// app-object.model.ts\nimport { ObjectType } from '../enums/common.enum';\nimport { ObjectCreationType } from '../enums/dsq.enum';\nimport { DeploymentStatus } from '../enums/permission.enum';\nimport { AppFieldModel } from './app-field.model';\nimport { ObjectAccess } from './app-object.class';\nimport { Resources } from './common.class';\nimport { DataSourceQueryModel } from './data-source-query.model';\n\nexport class AppObjectModel {\n  // Properties\n  readonly ID: string;\n  readonly ObjectName: string;\n  readonly DisplayName: string;\n  readonly Description: string;\n  readonly SystemDBTableName: string;\n  readonly IsSystem: boolean;\n  readonly IsVisible: boolean;\n  readonly IsDeprecated: boolean;\n  readonly IsSupportBluePrint: boolean | null;\n  readonly IsLocationTracking: boolean | null;\n  readonly ObjectType: ObjectType;\n  readonly DeploymentStatus: DeploymentStatus;\n  readonly CreationType: ObjectCreationType;\n  readonly AllowVersioning: boolean;\n  readonly EnableTracking: boolean;\n  readonly AllowSearchable: boolean;\n  readonly AllowReports: boolean;\n  readonly AllowActivities: boolean;\n  readonly AllowSharing: boolean;\n  readonly AllowSoftDelete: boolean | null;\n  readonly IsReplicationNeeded: boolean | null;\n  readonly IsCacheEnable: boolean | null;\n  readonly CacheTtl: number | null;\n  readonly AppObjectConfiguration: string;\n  readonly CRUDAppObjectId: string | null;\n  readonly ConnectionId: string | null;\n  readonly IsSupportLayout: boolean | null;\n  readonly AccessList: Array<ObjectAccess>;\n  readonly Resources: Array<Resources>;\n  readonly parsedAppObjectConfiguration: any;\n\n  // Cache maps\n  private readonly fieldMap = new Map<string, AppFieldModel>();\n  private readonly dsqMap = new Map<string, DataSourceQueryModel>();\n  private allFields: AppFieldModel[] = [];\n  private allDSQs: DataSourceQueryModel[] = [];\n\n  constructor(private readonly raw: any) {\n    this.ID = raw?.ID;\n    this.ObjectName = raw?.ObjectName;\n    this.DisplayName = raw?.DisplayName;\n    this.Description = raw?.Description;\n    this.SystemDBTableName = raw?.SystemDBTableName;\n    this.IsSystem = raw?.IsSystem;\n    this.IsVisible = raw?.IsVisible;\n    this.IsDeprecated = raw?.IsDeprecated;\n    this.IsSupportBluePrint = raw?.IsSupportBluePrint;\n    this.IsLocationTracking = raw?.IsLocationTracking;\n    this.ObjectType = raw?.ObjectType;\n    this.DeploymentStatus = raw?.DeploymentStatus;\n    this.CreationType = raw?.CreationType;\n    this.AllowVersioning = raw?.AllowVersioning;\n    this.EnableTracking = raw?.EnableTracking;\n    this.AllowSearchable = raw?.AllowSearchable;\n    this.AllowReports = raw?.AllowReports;\n    this.AllowActivities = raw?.AllowActivities;\n    this.AllowSharing = raw?.AllowSharing;\n    this.AllowSoftDelete = raw?.AllowSoftDelete;\n    this.IsReplicationNeeded = raw?.IsReplicationNeeded;\n    this.IsCacheEnable = raw?.IsCacheEnable;\n    this.CacheTtl = raw?.CacheTtl;\n    this.AppObjectConfiguration = raw?.AppObjectConfiguration;\n    this.CRUDAppObjectId = raw?.CRUDAppObjectId;\n    this.ConnectionId = raw?.ConnectionId;\n    this.IsSupportLayout = raw?.IsSupportLayout;\n    this.AccessList = raw?.AccessList;\n    this.Resources = raw?.Resources;\n\n    try {\n      this.parsedAppObjectConfiguration = JSON.parse(this.AppObjectConfiguration || '{}');\n    } catch (e) {\n      console.warn('Invalid AppObjectConfiguration JSON', e);\n      this.parsedAppObjectConfiguration = {};\n    }\n  }\n\n  /**\n   * Returns all fields associated with this AppObject. The fields are cached so that subsequent calls\n   * are faster. The cache is stored in a map by ID.\n   *\n   * @returns {AppFieldModel[]} An array of AppFieldModel objects.\n   */\n  fields(): AppFieldModel[] {\n    if (!this.allFields?.length) {\n      this.allFields = (this.raw?.Fields ?? []).map((field: any) => {\n        const model = new AppFieldModel(field);\n        // Cache the field in a map by ID\n        this.fieldMap.set(field?.ID, model);\n        return model;\n      });\n    }\n    return this.allFields;\n  }\n\n  /**\n   * Retrieves a field by its ID or name.\n   * If the field is cached, it returns it from the cache.\n   * Otherwise, it searches through all fields.\n   * \n   * @param {string} idOrName - The ID or name of the field to retrieve.\n   * @returns {AppFieldModel | undefined} - The field model if found, otherwise undefined.\n   */\n  field(idOrName: string): AppFieldModel | undefined {\n    // Ensure all fields are loaded and cached\n    this.fields();\n\n    // Check if the field is available in the cache map\n    if (this.fieldMap.has(idOrName)) {\n      return this.fieldMap.get(idOrName);\n    }\n\n    // Convert the idOrName to lowercase for case-insensitive search\n    const idLower = idOrName.toLowerCase();\n\n    // Find the field by matching ID or name, case-insensitively\n    return this.allFields?.find(\n      f => f.FieldName?.toLowerCase() === idLower || f.DisplayName?.toLowerCase() === idLower\n    );\n  }\n\n  /**\n   * Retrieves all fields of the app object that are lookup fields.\n   * A lookup field is a field that has a relationship with another field.\n   * It is used to perform lookups, such as retrieving a list of values\n   * from a related field.\n   * \n   * @returns {AppFieldModel[]} - An array of AppFieldModel objects that are lookup fields.\n   */\n  lookupFields(): AppFieldModel[] {\n    return this.fields().filter(field => field.IsLookup);\n  }\n\n  /**\n   * Finds and returns the fields for the app object that satisfy the given filter function.\n   * The filter function is called with each field as an argument, and should return true if the field\n   * should be included in the result.\n   * @param {function} filterFn The filter function to apply to the fields.\n   * @returns {AppFieldModel[]} The array of fields that satisfy the filter function.\n   */\n  findFields(filterFn: (field: AppFieldModel) => boolean): AppFieldModel[] {\n    return this.fields().filter(filterFn);\n  }\n\n  /**\n   * Retrieves all data source queries associated with this AppObject. \n   * The queries are cached for faster subsequent access. The cache is stored in a map by ID, QueryName, and DisplayName.\n   *\n   * @returns {DataSourceQueryModel[]} An array of DataSourceQueryModel objects.\n   */\n  dataSourceQueries(): DataSourceQueryModel[] {\n    // Check if allDSQs is empty or undefined\n    if (!this.allDSQs?.length) {\n      // Map the raw DataSourceQueries to DataSourceQueryModel instances\n      this.allDSQs = (this.raw?.DataSourceQueries ?? []).map((dsq: any) => {\n        const model = new DataSourceQueryModel(dsq, this);\n        // Cache the DataSourceQuery in a map by ID, QueryName, and DisplayName\n        this.dsqMap.set(dsq?.ID, model);\n        this.dsqMap.set(dsq?.QueryName, model);\n        this.dsqMap.set(dsq?.DisplayName, model);\n        return model;\n      });\n    }\n    return this.allDSQs;\n  }\n\n  /**\n   * Retrieves a data source query by its ID or name.\n   * If the query is cached, it returns it from the cache.\n   * Otherwise, it searches through all data source queries.\n   * \n   * @param {string} idOrName - The ID or name of the data source query to retrieve.\n   * @returns {DataSourceQueryModel | undefined} - The data source query model if found, otherwise undefined.\n   */\n  dataSourceQuery(idOrName: string): DataSourceQueryModel | undefined {\n    // Ensure all data source queries are loaded and cached\n    this.dataSourceQueries();\n\n    // Check if the data source query is available in the cache map\n    if (this.dsqMap.has(idOrName)) {\n      return this.dsqMap.get(idOrName);\n    }\n\n    // Convert the idOrName to lowercase for case-insensitive search\n    const idLower = idOrName.toLowerCase();\n\n    // Find the data source query by matching QueryName or DisplayName, case-insensitively\n    return this.allDSQs?.find(\n      dsq => dsq.QueryName?.toLowerCase() === idLower || dsq.DisplayName?.toLowerCase() === idLower\n    );\n  }\n\n  /**\n   * Finds and returns the data source queries that satisfy the given filter function.\n   * The filter function is called with each data source query as an argument.\n   * If the filter function returns true, the data source query is included in the result.\n   * \n   * @param {function} filterFn - The filter function to apply to the data source queries.\n   * @returns {DataSourceQueryModel[]} - The array of data source queries that satisfy the filter function.\n   */\n  findDataSourceQueries(filterFn: (dsq: DataSourceQueryModel) => boolean): DataSourceQueryModel[] {\n    return this.dataSourceQueries().filter(filterFn);\n  }\n\n  /**\n   * Searches for the given term in the fields and data source queries of this AppObject.\n   * The search is case-insensitive and performed on the following fields:\n   *   - Field name and description\n   *   - Data source query name, display name, and description\n   * \n   * @param {string} term - The search term to search for.\n   * @returns {{ fields: AppFieldModel[]; dsqs: DataSourceQueryModel[] }} - An object with the search results.\n   *   The `fields` property contains an array of AppFieldModel objects that match the search term.\n   *   The `dsqs` property contains an array of DataSourceQueryModel objects that match the search term.\n   */\n  search(term: string): { fields: AppFieldModel[]; dsqs: DataSourceQueryModel[] } {\n    // Search for the term in the fields\n    const fields = this.fields().filter(field => field.search(term));\n\n    // Search for the term in the data source queries\n    const dsqs = this.dataSourceQueries().filter(dsq => dsq.search(term));\n\n    // Return the search results\n    return { fields, dsqs };\n  }\n\n  /**\n   * Converts the current object to a JSON object.\n   *\n   * @returns {any} The raw data as a JSON object.\n   */\n  toJSON(): any {\n    return this.raw;\n  }\n}"]}

package/esm2022/lib/tab-core-utility/app/models/app-screen.model.mjs

@@ -0,0 +1,37 @@
+export class AppScreenModel {
+    constructor(raw) {
+        this.raw = raw;
+        this.ID = raw?.ID;
+        this.Name = raw?.Name;
+        this.Description = raw?.Description;
+        this.ScreenType = raw?.ScreenType;
+        this.DataSourceQuery = raw?.DataSourceQuery;
+        this.Container = raw?.Container;
+        this.ScreenConfiguration = raw?.ScreenConfiguration;
+        this.AppId = raw?.AppId;
+        this.RecordId = raw?.RecordId;
+        this.IsSystemRecord = raw?.IsSystemRecord;
+    }
+    /**
+     * Searches for the given term in the properties of the current app screen
+     * @param {string} term The search term
+     * @returns {boolean} Whether the search term is present in any field
+     */
+    search(term) {
+        const lower = term.toLowerCase();
+        return Boolean(
+        // Search in ID
+        (this.ID && this.ID?.toLowerCase()?.includes(lower)) ||
+            // Search in Name
+            (this.Name && this.Name?.toLowerCase()?.includes(lower)));
+    }
+    /**
+     * Converts the current object to a JSON object.
+     *
+     * @returns A JSON representation of the current object.
+     */
+    toJSON() {
+        return this.raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/models/common.class.mjs

@@ -9,4 +9,4 @@ export class Resources {
 }
 export class EmailTemplate {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kYXRhLWFjY2Vzcy9zcmMvbGliL3RhYi1jb3JlLXV0aWxpdHkvYXBwL21vZGVscy9jb21tb24uY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdURBQXVEO0FBRXZELE1BQU0sT0FBTyxJQUFJO0NBS2hCO0FBRUQsTUFBTSxPQUFPLGNBQWM7Q0FJMUI7QUFFRCxNQUFNLE9BQU8sT0FBTztDQUluQjtBQUVELE1BQU0sT0FBTyxTQUFTO0NBR3JCO0FBRUQsTUFBTSxPQUFPLGFBQWE7Q0FHekIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZXhwbGljaXQtYW55ICovXHJcblxyXG5leHBvcnQgY2xhc3MgUm9sZSB7XHJcbiAgSUQ6IHN0cmluZyB8IGFueTtcclxuICBSb2xlTmFtZTogc3RyaW5nIHwgYW55O1xyXG4gIERlc2NyaXB0aW9uOiBzdHJpbmcgfCBhbnk7XHJcbiAgUGFyZW50Um9sZTogUm9sZSB8IGFueTtcclxufVxyXG5cclxuZXhwb3J0IGNsYXNzIENvbmZpZ3VyYXRpb25zIHtcclxuICBJRDogc3RyaW5nIHwgYW55O1xyXG4gIFNldHRpbmdfS2V5OiBzdHJpbmcgfCBhbnk7XHJcbiAgVmFsdWU6IHN0cmluZyB8IGFueTtcclxufVxyXG5cclxuZXhwb3J0IGNsYXNzIFByb2ZpbGUge1xyXG4gIElEITogc3RyaW5nO1xyXG4gIFByb2ZpbGVOYW1lITogc3RyaW5nO1xyXG4gIERlc2NyaXB0aW9uITogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgY2xhc3MgUmVzb3VyY2VzIHtcclxuICBJRCE6IHN0cmluZztcclxuICBWYWx1ZSE6IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGNsYXNzIEVtYWlsVGVtcGxhdGUge1xyXG4gIElEITogc3RyaW5nO1xyXG4gIFRlbXBsYXRlITogc3RyaW5nO1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kYXRhLWFjY2Vzcy9zcmMvbGliL3RhYi1jb3JlLXV0aWxpdHkvYXBwL21vZGVscy9jb21tb24uY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdURBQXVEO0FBSXZELE1BQU0sT0FBTyxJQUFJO0NBS2hCO0FBRUQsTUFBTSxPQUFPLGNBQWM7Q0FJMUI7QUFFRCxNQUFNLE9BQU8sT0FBTztDQUluQjtBQUVELE1BQU0sT0FBTyxTQUFTO0NBS3JCO0FBRUQsTUFBTSxPQUFPLGFBQWE7Q0FHekIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZXhwbGljaXQtYW55ICovXHJcblxyXG5pbXBvcnQgeyBSZXNvdXJjZVR5cGUgfSBmcm9tIFwiLi4vZW51bXMvY29tbW9uLmVudW1cIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBSb2xlIHtcclxuICBJRDogc3RyaW5nIHwgYW55O1xyXG4gIFJvbGVOYW1lOiBzdHJpbmcgfCBhbnk7XHJcbiAgRGVzY3JpcHRpb246IHN0cmluZyB8IGFueTtcclxuICBQYXJlbnRSb2xlOiBSb2xlIHwgYW55O1xyXG59XHJcblxyXG5leHBvcnQgY2xhc3MgQ29uZmlndXJhdGlvbnMge1xyXG4gIElEOiBzdHJpbmcgfCBhbnk7XHJcbiAgU2V0dGluZ19LZXk6IHN0cmluZyB8IGFueTtcclxuICBWYWx1ZTogc3RyaW5nIHwgYW55O1xyXG59XHJcblxyXG5leHBvcnQgY2xhc3MgUHJvZmlsZSB7XHJcbiAgSUQhOiBzdHJpbmc7XHJcbiAgUHJvZmlsZU5hbWUhOiBzdHJpbmc7XHJcbiAgRGVzY3JpcHRpb24hOiBzdHJpbmc7XHJcbn1cclxuXHJcbmV4cG9ydCBjbGFzcyBSZXNvdXJjZXMge1xyXG4gIElEITogc3RyaW5nO1xyXG4gIFZhbHVlITogc3RyaW5nO1xyXG4gIFNldHRpbmdfS2V5ITogc3RyaW5nO1xyXG4gIHJlc291cmNlVHlwZSE6IFJlc291cmNlVHlwZTtcclxufVxyXG5cclxuZXhwb3J0IGNsYXNzIEVtYWlsVGVtcGxhdGUge1xyXG4gIElEITogc3RyaW5nO1xyXG4gIFRlbXBsYXRlITogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/lib/tab-core-utility/app/models/data-source-queries.class.mjs

@@ -28,4 +28,4 @@ export class UpdateQueryParameter {
 }
 export class ScreenParameter {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/models/data-source-query.model.mjs

@@ -0,0 +1,123 @@
+import { FilterModel } from './filter.model';
+import { ParameterModel } from './parameter.model';
+import { SortModel } from './sort.model';
+export class DataSourceQueryModel {
+    constructor(raw, parentAppObject) {
+        this.raw = raw;
+        this.parentAppObject = parentAppObject;
+        this.enrichedFields = [];
+        this.cachedParameters = [];
+        this.cachedFilters = [];
+        this.cachedSorts = [];
+        this.ID = raw.ID;
+        this.ObjectID = raw.ObjectID;
+        this.ObjectID_Tosave = raw.ObjectID_Tosave;
+        this.QueryName = raw.QueryName;
+        this.DisplayName = raw.DisplayName;
+        this.FilterLogic = raw.FilterLogic;
+    }
+    /**
+     * Gets the fields for the data source query. The fields are enriched with the corresponding `AppFieldModel` objects.
+     * @returns {DataSourceQueries_Fields[]} The array of enriched fields.
+     */
+    fields() {
+        if (!this.enrichedFields?.length) {
+            const rawFields = this.raw?.Fields;
+            if (rawFields?.length) {
+                // Enrich the fields by mapping each field to the corresponding `AppFieldModel` object.
+                this.enrichedFields = rawFields.map((field) => ({
+                    ...field,
+                    // The `Field` property contains the corresponding `AppFieldModel` object.
+                    Field: this.parentAppObject.field(field.AppFieldID)
+                }));
+            }
+            else {
+                // If there are no fields, return an empty array.
+                this.enrichedFields = [];
+            }
+        }
+        // Return the enriched fields.
+        return this.enrichedFields;
+    }
+    /**
+     * Finds and returns the fields for the data source query that satisfy the given filter function.
+     * @param {function} filterFn The filter function to apply to the fields.
+     * @returns {DataSourceQueries_Fields[]} The array of fields that satisfy the filter function.
+     */
+    findFields(filterFn) {
+        return this.fields().filter(filterFn);
+    }
+    /**
+     * Retrieves and caches the parameters for the data source query.
+     * @returns {ParameterModel[]} The array of ParameterModel instances.
+     */
+    parameters() {
+        // Check if parameters have already been cached
+        if (!this.cachedParameters) {
+            // Map raw parameters to ParameterModel instances and cache them
+            this.cachedParameters = (this.raw?.Parameters || []).map((p) => new ParameterModel(p));
+        }
+        return this.cachedParameters;
+    }
+    /**
+     * Retrieves the mandatory parameters for the data source query.
+     * @returns {ParameterModel[]} The array of mandatory ParameterModel instances.
+     */
+    mandatoryParameters() {
+        return this.parameters().filter(p => p.IsMandatory);
+    }
+    /**
+     * Finds a parameter by its name (case-insensitive).
+     * @param {string} name The name of the parameter to find.
+     * @returns {ParameterModel | undefined} The parameter model instance if found, otherwise undefined.
+     */
+    parameter(name) {
+        const nameLower = name.toLowerCase();
+        return this.parameters().find(p => p.ParameterName?.toLowerCase() === nameLower);
+    }
+    /**
+     * Retrieves and caches the filters for the data source query.
+     * @returns {FilterModel[]} The array of FilterModel instances.
+     */
+    filters() {
+        // Check if filters have already been cached
+        if (!this.cachedFilters) {
+            // Map raw filters to FilterModel instances and cache them
+            this.cachedFilters = (this.raw.Filters?.Filters || []).map((f) => new FilterModel(f));
+        }
+        return this.cachedFilters;
+    }
+    /**
+     * Retrieves and caches the sorts for the data source query.
+     * @returns {SortModel[]} The array of SortModel instances.
+     */
+    sorts() {
+        // Check if sorts have already been cached
+        if (!this.cachedSorts) {
+            // Map raw sorts to SortModel instances and cache them
+            this.cachedSorts = (this.raw.Sort || []).map((s) => new SortModel(s));
+        }
+        // Return the cached sorts
+        return this.cachedSorts;
+    }
+    /**
+     * Check if the given search term is present in any of the fields of the
+     * current data source query
+     * @param {string} term The search term
+     * @returns {boolean} Whether the search term is present in any field
+     */
+    search(term) {
+        const searchTerm = term.toLowerCase();
+        return (this.ID?.toLowerCase().includes(searchTerm) ||
+            this.QueryName?.toLowerCase().includes(searchTerm) ||
+            this.DisplayName?.toLowerCase().includes(searchTerm));
+    }
+    /**
+     * Converts the DataSourceQueryModel instance to a JSON representation.
+     * @returns {any} The raw data in JSON format.
+     */
+    toJSON() {
+        return this.raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-source-query.model.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/models/data-source-query.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { AppObjectModel } from './app-object.model';\nimport { DataSourceQueries_Fields } from './data-source-queries.class';\nimport { FilterModel } from './filter.model';\nimport { ParameterModel } from './parameter.model';\nimport { SortModel } from './sort.model';\n\nexport class DataSourceQueryModel {\n  readonly ID: string;\n  readonly ObjectID: string;\n  readonly ObjectID_Tosave: string;\n  readonly QueryName: string;\n  readonly DisplayName: string;\n  readonly FilterLogic: string | null;\n\n  private enrichedFields: DataSourceQueries_Fields[] = [];\n  private cachedParameters: ParameterModel[] = [];\n  private cachedFilters: FilterModel[] = [];\n  private cachedSorts: SortModel[] = [];\n\n  constructor(\n    private readonly raw: any,\n    private readonly parentAppObject: AppObjectModel\n  ) {\n    this.ID = raw.ID;\n    this.ObjectID = raw.ObjectID;\n    this.ObjectID_Tosave = raw.ObjectID_Tosave;\n    this.QueryName = raw.QueryName;\n    this.DisplayName = raw.DisplayName;\n    this.FilterLogic = raw.FilterLogic;\n  }\n\n  /**\n   * Gets the fields for the data source query. The fields are enriched with the corresponding `AppFieldModel` objects.\n   * @returns {DataSourceQueries_Fields[]} The array of enriched fields.\n   */\n  fields(): DataSourceQueries_Fields[] {\n    if (!this.enrichedFields?.length) {\n      const rawFields = this.raw?.Fields;\n      if (rawFields?.length) {\n        // Enrich the fields by mapping each field to the corresponding `AppFieldModel` object.\n        this.enrichedFields = rawFields.map((field: any) => ({\n          ...field,\n          // The `Field` property contains the corresponding `AppFieldModel` object.\n          Field: this.parentAppObject.field(field.AppFieldID)\n        }));\n      } else {\n        // If there are no fields, return an empty array.\n        this.enrichedFields = [];\n      }\n    }\n    // Return the enriched fields.\n    return this.enrichedFields;\n  }\n\n  /**\n   * Finds and returns the fields for the data source query that satisfy the given filter function.\n   * @param {function} filterFn The filter function to apply to the fields.\n   * @returns {DataSourceQueries_Fields[]} The array of fields that satisfy the filter function.\n   */\n  findFields(filterFn: (field: DataSourceQueries_Fields) => boolean): DataSourceQueries_Fields[] {\n    return this.fields().filter(filterFn);\n  }\n\n  /**\n   * Retrieves and caches the parameters for the data source query.\n   * @returns {ParameterModel[]} The array of ParameterModel instances.\n   */\n  parameters(): ParameterModel[] {\n    // Check if parameters have already been cached\n    if (!this.cachedParameters) {\n      // Map raw parameters to ParameterModel instances and cache them\n      this.cachedParameters = (this.raw?.Parameters || []).map((p: any) => new ParameterModel(p));\n    }\n    return this.cachedParameters;\n  }\n\n  /**\n   * Retrieves the mandatory parameters for the data source query.\n   * @returns {ParameterModel[]} The array of mandatory ParameterModel instances.\n   */\n  mandatoryParameters(): ParameterModel[] {\n    return this.parameters().filter(p => p.IsMandatory);\n  }\n\n  /**\n   * Finds a parameter by its name (case-insensitive).\n   * @param {string} name The name of the parameter to find.\n   * @returns {ParameterModel | undefined} The parameter model instance if found, otherwise undefined.\n   */\n  parameter(name: string): ParameterModel | undefined {\n    const nameLower = name.toLowerCase();\n    return this.parameters().find(p => p.ParameterName?.toLowerCase() === nameLower);\n  }\n\n  /**\n   * Retrieves and caches the filters for the data source query.\n   * @returns {FilterModel[]} The array of FilterModel instances.\n   */\n  filters(): FilterModel[] {\n    // Check if filters have already been cached\n    if (!this.cachedFilters) {\n      // Map raw filters to FilterModel instances and cache them\n      this.cachedFilters = (this.raw.Filters?.Filters || []).map((f: any) => new FilterModel(f));\n    }\n    return this.cachedFilters;\n  }\n\n  /**\n   * Retrieves and caches the sorts for the data source query.\n   * @returns {SortModel[]} The array of SortModel instances.\n   */\n  sorts(): SortModel[] {\n    // Check if sorts have already been cached\n    if (!this.cachedSorts) {\n      // Map raw sorts to SortModel instances and cache them\n      this.cachedSorts = (this.raw.Sort || []).map((s: any) => new SortModel(s));\n    }\n    // Return the cached sorts\n    return this.cachedSorts;\n  }\n\n  /**\n   * Check if the given search term is present in any of the fields of the\n   * current data source query\n   * @param {string} term The search term\n   * @returns {boolean} Whether the search term is present in any field\n   */\n  search(term: string): boolean {\n    const searchTerm = term.toLowerCase();\n    return (\n      this.ID?.toLowerCase().includes(searchTerm) ||\n      this.QueryName?.toLowerCase().includes(searchTerm) ||\n      this.DisplayName?.toLowerCase().includes(searchTerm)\n    );\n  }\n\n  /**\n   * Converts the DataSourceQueryModel instance to a JSON representation.\n   * @returns {any} The raw data in JSON format.\n   */\n  toJSON(): any {\n    return this.raw;\n  }\n}"]}

package/esm2022/lib/tab-core-utility/app/models/filter.model.mjs

@@ -0,0 +1,24 @@
+export class FilterModel {
+    constructor(raw) {
+        this.raw = raw;
+        this.ID = raw?.ID;
+        this.ConjuctionClause = raw?.ConjuctionClause;
+        this.RelationalOperator = raw?.RelationalOperator;
+        this.ValueType = raw?.ValueType;
+        this.value = raw?.value;
+        this.Sequence = raw?.Sequence;
+        this.GroupID = raw?.GroupID;
+        this.LookupDetail = raw?.LookupDetail;
+        this.FieldType = raw?.FieldType;
+        this.FieldID = raw?.FieldID;
+    }
+    /**
+     * Converts the current object to a JSON object.
+     *
+     * @returns A JSON representation of the current object.
+     */
+    toJSON() {
+        return this.raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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