@techextensor/tab-core-utility 2.2.11 → 2.2.14

package/esm2022/lib/tab-core-utility/app/crud/tab-get.service.mjs

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpHeaders } from "@angular/common/http";
+import { Injectable, inject } from "@angular/core";
+import { ApiService } from "../../core/http-client/api.service";
+import { DSQHelper } from "../helpers/common/dsq.helpers";
+import { getHeaders } from "../utils/req-res.util";
+import { API } from "../constants/api-constants";
+import { getAppObject } from "../utils/tab-app.util";
+import { Common } from "../constants/common";
+import { FilterValueType } from "../enums/dsq.enum";
+import { QueryType } from "../enums/query.enum";
+import * as i0 from "@angular/core";
+export class TabGetService {
+    constructor() {
+        this.apiService = inject(ApiService);
+        this.dsqHelper = inject(DSQHelper);
+    }
+    /**
+     * Execute RAW DSQ with Name
+     * @param data - Object containing AppObjectName and DSQName
+     * @returns Response from the API
+     */
+    executeRAWDSQWithName(data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(`${API.getDSQ}/${data.AppObjectName}/${data.DSQName}`, data, headers);
+        }
+        return null;
+    }
+    /**
+     * Get Record
+     * @param params - Parameters for the request
+     * @returns Response from the API
+     */
+    getRecord(params) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.get(`${API.getrecord}`, params, headers);
+        }
+        return null;
+    }
+    /**
+     * Execute Raw SQL
+     * @param data - Data for the request
+     * @returns Response from the API
+     */
+    executeRawSql(data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(`${API.rawSQL}${data}`, '', headers);
+        }
+        return null;
+    }
+    /**
+     * Get History
+     * @param appObjectId - ID of the application object
+     * @param recordIds - Array of record IDs
+     * @returns Response from the API
+     */
+    getHistory(appObjectId, recordIds) {
+        const data = {};
+        if (appObjectId && recordIds) {
+            const appObjectName = getAppObject(appObjectId)?.ObjectName;
+            const headers = getHeaders();
+            if (appObjectName && headers) {
+                data.ObjectName = appObjectName;
+                data.RecordIds = recordIds;
+                return this.apiService.post(`${API.getHistory}`, data, headers);
+            }
+        }
+        return null;
+    }
+    /**
+     * Change Password
+     * @param data - Data for changing password
+     * @returns Response from the API
+     */
+    changePassword(data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(`${API.changePassword}`, data, headers);
+        }
+    }
+    /**
+     * Reset Password
+     * @param data - Data for resetting password
+     * @returns Response from the API
+     */
+    resetPassword(data) {
+        const headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            applicationCode: Common.applicationCode,
+        });
+        return this.apiService.post(`${API.restpassword}`, data, headers);
+    }
+    /**
+     * PMJAY Import
+     * @param data - Data for PMJAY import
+     * @returns Response from the API
+     */
+    pmjayImport(data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(`${API.pmjayImport}`, data, headers);
+        }
+    }
+    /**
+     * Executes a select query with optional parameters
+     * @param data - The select query data
+     * @param parameters - Optional parameters to be applied to the query
+     * @returns Result of the select query execution
+     */
+    selectExecutor(data, parameters) {
+        if (parameters && Object.keys(parameters).length) {
+            data?.WhereClause?.Filters.forEach((element) => {
+                if (element.ValueType === FilterValueType.Parameter &&
+                    parameters[element.FieldID]) {
+                    element.Value = parameters[element.FieldID];
+                }
+            });
+        }
+        return this.dsqHelper.executeQuery(data, QueryType.Select);
+    }
+    static { this.ɵfac = function TabGetService_Factory(t) { return new (t || TabGetService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabGetService, factory: TabGetService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TabGetService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-get.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-get.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { HttpHeaders } from \"@angular/common/http\";\r\nimport { Injectable, inject } from \"@angular/core\";\r\nimport { ApiService } from \"../../core/http-client/api.service\";\r\nimport { DSQHelper } from \"../helpers/common/dsq.helpers\";\r\nimport { getHeaders } from \"../utils/req-res.util\";\r\nimport { API } from \"../constants/api-constants\";\r\nimport { getAppObject } from \"../utils/tab-app.util\";\r\nimport { Common } from \"../constants/common\";\r\nimport { APISelectQuery } from \"../models/api-query.class\";\r\nimport { FilterValueType } from \"../enums/dsq.enum\";\r\nimport { QueryType } from \"../enums/query.enum\";\r\n\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabGetService {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly dsqHelper = inject(DSQHelper);\r\n\r\n  /**\r\n   * Execute RAW DSQ with Name\r\n   * @param data - Object containing AppObjectName and DSQName\r\n   * @returns Response from the API\r\n   */\r\n  executeRAWDSQWithName(data: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        `${API.getDSQ}/${data.AppObjectName}/${data.DSQName}`,\r\n        data,\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Get Record\r\n   * @param params - Parameters for the request\r\n   * @returns Response from the API\r\n   */\r\n  getRecord(params: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(`${API.getrecord}`, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Execute Raw SQL\r\n   * @param data - Data for the request\r\n   * @returns Response from the API\r\n   */\r\n  executeRawSql(data: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        `${API.rawSQL}${data}`,\r\n        '',\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Get History\r\n   * @param appObjectId - ID of the application object\r\n   * @param recordIds - Array of record IDs\r\n   * @returns Response from the API\r\n   */\r\n  getHistory(appObjectId: string, recordIds: string[]): any {\r\n    const data: any = {};\r\n    if (appObjectId && recordIds) {\r\n      const appObjectName = getAppObject(appObjectId)?.ObjectName;\r\n      const headers = getHeaders();\r\n      if (appObjectName && headers) {\r\n        data.ObjectName = appObjectName;\r\n        data.RecordIds = recordIds;\r\n        return this.apiService.post(\r\n          `${API.getHistory}`,\r\n          data,\r\n          headers\r\n        );\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Change Password\r\n   * @param data - Data for changing password\r\n   * @returns Response from the API\r\n   */\r\n  changePassword(data: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        `${API.changePassword}`,\r\n        data,\r\n        headers\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reset Password\r\n   * @param data - Data for resetting password\r\n   * @returns Response from the API\r\n   */\r\n  resetPassword(data: any): any {\r\n    const headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      applicationCode: Common.applicationCode,\r\n    });\r\n    return this.apiService.post(\r\n      `${API.restpassword}`,\r\n      data,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * PMJAY Import\r\n   * @param data - Data for PMJAY import\r\n   * @returns Response from the API\r\n   */\r\n  pmjayImport(data: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        `${API.pmjayImport}`,\r\n        data,\r\n        headers\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Executes a select query with optional parameters\r\n   * @param data - The select query data\r\n   * @param parameters - Optional parameters to be applied to the query\r\n   * @returns Result of the select query execution\r\n   */\r\n  selectExecutor(data: APISelectQuery, parameters?: any): any {\r\n    if (parameters && Object.keys(parameters).length) {\r\n      data?.WhereClause?.Filters.forEach((element: any) => {\r\n        if (\r\n          element.ValueType === FilterValueType.Parameter &&\r\n          parameters[element.FieldID]\r\n        ) {\r\n          element.Value = parameters[element.FieldID];\r\n        }\r\n      });\r\n    }\r\n    return this.dsqHelper.executeQuery(data, QueryType.Select);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/crud/tab-insert.service.mjs

@@ -0,0 +1,77 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable, inject } from '@angular/core';
+import { DSQHelper } from '../helpers/common/dsq.helpers';
+import { ScreenHelper } from '../helpers/screen/screen.helpers';
+import { WhereClauseHelper } from '../helpers/common/where-clause.helpers';
+import { RequestResponseHelper } from '../helpers/common/req-res.helpers';
+import { getAppObject, getDataFromDataSourceQueryID, syncAppObjectFields } from '../utils/tab-app.util';
+import { getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from '../utils/req-res.util';
+import { createDynamicData, removeBlankValue } from '../utils/json.util';
+import { QueryType } from '../enums/query.enum';
+import * as i0 from "@angular/core";
+export class TabInsertService {
+    constructor() {
+        this.dsqHelper = inject(DSQHelper);
+        this.screenHelper = inject(ScreenHelper);
+        this.whereClauseHelper = inject(WhereClauseHelper);
+        this.requestResponseHelper = inject(RequestResponseHelper);
+    }
+    /**
+     * Inserts data by screen ID.
+     * @param screenId The ID of the screen.
+     * @param data The data to insert.
+     * @returns An Observable with the insert result.
+     */
+    insertByScreenId(screenId, data) {
+        const screen = this.screenHelper.getScreen(screenId);
+        const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);
+        return this.insertByObjectId(screenDataSource.ObjectID_Tosave, data);
+    }
+    /**
+     * Inserts data by object ID.
+     * @param objectId The ID of the object.
+     * @param data The data to insert.
+     * @returns An Observable with the insert result.
+     */
+    insertByObjectId(objectId, data) {
+        const appObject = getAppObject(objectId);
+        return this.prepareInsert(appObject, data);
+    }
+    /**
+     * Prepares data for insertion.
+     * @param appObject The app object.
+     * @param data The data to insert.
+     * @returns An Observable with the prepared data.
+     */
+    prepareInsert(appObject, data) {
+        const crudTableName = appObject.SystemDBTableName;
+        syncAppObjectFields(data.data, appObject);
+        const PrimaryKeyFields = getPrimaryKeyFields(appObject);
+        if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
+            removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
+        }
+        else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
+            removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
+        }
+        const whereClause = this.whereClauseHelper.bindWhereClauseForInsert();
+        const dataObj = createDynamicData(data.data);
+        removeBlankValue(dataObj);
+        const requestPayload = this.requestResponseHelper.insertPayload(crudTableName, whereClause, dataObj);
+        return this.insert(requestPayload);
+    }
+    /**
+     * Inserts data.
+     * @param data The data to insert.
+     * @returns An Observable with the insert result.
+     */
+    insert(data) {
+        return this.dsqHelper.executeQuery(data, QueryType.Insert);
+    }
+    static { this.ɵfac = function TabInsertService_Factory(t) { return new (t || TabInsertService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabInsertService, factory: TabInsertService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TabInsertService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/crud/tab-update.service.mjs

@@ -0,0 +1,105 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable, inject } from "@angular/core";
+import { DSQHelper } from "../helpers/common/dsq.helpers";
+import { ScreenHelper } from "../helpers/screen/screen.helpers";
+import { WhereClauseHelper } from "../helpers/common/where-clause.helpers";
+import { RequestResponseHelper } from "../helpers/common/req-res.helpers";
+import { APIFilterCriteria } from "../models/api-query.class";
+import { QueryType } from "../enums/query.enum";
+import { getAppObject, getAppObjectFromSystemDBTableName, getDataFromDataSourceQueryID, syncAppObjectFields } from "../utils/tab-app.util";
+import { AppObject } from "../models/app-object.class";
+import { createDynamicData, removeBlankValue } from "../utils/json.util";
+import { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from "../utils/req-res.util";
+import * as i0 from "@angular/core";
+export class TabUpdateService {
+    constructor() {
+        this.dsqHelper = inject(DSQHelper);
+        this.screenHelper = inject(ScreenHelper);
+        this.whereClauseHelper = inject(WhereClauseHelper);
+        this.requestResponseHelper = inject(RequestResponseHelper);
+    }
+    update(data) {
+        return this.dsqHelper.executeQuery(data, QueryType.Update);
+    }
+    updateUsingDSQ(dsqId, data, tableName, queryFieldsArray) {
+        const appObject = getDataFromDataSourceQueryID(dsqId);
+        if (appObject) {
+            if (data && data.data) {
+                const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate(tableName, queryFieldsArray);
+                let dataObj = [];
+                dataObj = createDynamicData(data.data);
+                const requestPayload = this.requestResponseHelper.updateRequestPayload(tableName, whereClause, dataObj);
+                return this.update(requestPayload);
+            }
+        }
+        return null;
+    }
+    updateUsingScreenId(screenId, data, objectIdToSave) {
+        let fields;
+        let appObject = AppObject;
+        let crudTableName;
+        if (screenId) {
+            const screen = this.screenHelper.getScreen(screenId);
+            const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);
+            fields = screenDataSource.Fields;
+            appObject = getAppObject(screenDataSource.ObjectID_Tosave);
+            crudTableName = appObject.SystemDBTableName;
+            syncAppObjectFields(data.data, appObject);
+        }
+        if (objectIdToSave) {
+            fields = [];
+            appObject = getAppObject(objectIdToSave);
+            appObject.Fields.forEach((element) => {
+                fields.push({ Field: element });
+            });
+            crudTableName = appObject.SystemDBTableName;
+            syncAppObjectFields(data.data, appObject);
+        }
+        const PrimaryKeyFields = getPrimaryKeyFields(appObject);
+        let whereClause = APIFilterCriteria;
+        if (appObject) {
+            if (data.data) {
+                const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);
+                data['recordId'] = recordId;
+                if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
+                    removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
+                    whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);
+                }
+                else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
+                    whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);
+                    removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
+                }
+                const dataObj = createDynamicData(data.data);
+                removeBlankValue(dataObj);
+                const requestPayload = this.requestResponseHelper.updateRequestPayload(crudTableName, whereClause, dataObj);
+                return this.update(requestPayload);
+            }
+        }
+        return null;
+    }
+    updateScreen(screenId, screenData) {
+        const screen = this.screenHelper.getScreen(screenId);
+        if (screen) {
+            const appObject = getAppObjectFromSystemDBTableName('TABMD_AppScreen');
+            if (appObject) {
+                syncAppObjectFields(screenData, appObject);
+            }
+            Object.assign({}, screen, { Container: screenData.Container });
+            const queryFilters = [];
+            queryFilters.push({ FieldName: 'ID', FieldValue: screenId });
+            const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate('TABMD_AppScreen', queryFilters);
+            const dataObj = createDynamicData(screenData);
+            removeBlankValue(dataObj);
+            const requestPayload = this.requestResponseHelper.updateRequestPayload('TABMD_AppScreen', whereClause, dataObj);
+            return this.update(requestPayload);
+        }
+        return null;
+    }
+    static { this.ɵfac = function TabUpdateService_Factory(t) { return new (t || TabUpdateService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabUpdateService, factory: TabUpdateService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TabUpdateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-update.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-update.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Injectable, inject } from \"@angular/core\";\r\nimport { DSQHelper } from \"../helpers/common/dsq.helpers\";\r\nimport { ScreenHelper } from \"../helpers/screen/screen.helpers\";\r\nimport { WhereClauseHelper } from \"../helpers/common/where-clause.helpers\";\r\nimport { RequestResponseHelper } from \"../helpers/common/req-res.helpers\";\r\nimport { APIFilterCriteria, APIUpdateQuery } from \"../models/api-query.class\";\r\nimport { QueryType } from \"../enums/query.enum\";\r\nimport { getAppObject, getAppObjectFromSystemDBTableName, getDataFromDataSourceQueryID, syncAppObjectFields } from \"../utils/tab-app.util\";\r\nimport { AppObject, AppScreen } from \"../models/app-object.class\";\r\nimport { createDynamicData, removeBlankValue } from \"../utils/json.util\";\r\nimport { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from \"../utils/req-res.util\";\r\nimport { UpdateQueryParameter } from \"../models/data-source-queries.class\";\r\n\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabUpdateService {\r\n  private readonly dsqHelper = inject(DSQHelper);\r\n  private readonly screenHelper = inject(ScreenHelper);\r\n  private readonly whereClauseHelper = inject(WhereClauseHelper);\r\n  private readonly requestResponseHelper = inject(RequestResponseHelper);\r\n\r\n  update(data: APIUpdateQuery) {\r\n    return this.dsqHelper.executeQuery(data, QueryType.Update);\r\n  }\r\n\r\n  updateUsingDSQ(dsqId: string, data: any, tableName: string, queryFieldsArray?: any) {\r\n    const appObject: AppObject = getDataFromDataSourceQueryID(dsqId);\r\n    if (appObject) {\r\n      if (data && data.data) {\r\n        const whereClause: APIFilterCriteria = this.whereClauseHelper.bindWhereClauseForUpdate(tableName, queryFieldsArray);\r\n        let dataObj: any = [];\r\n        dataObj = createDynamicData(data.data);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(tableName, whereClause, dataObj);\r\n        return this.update(requestPayload);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  updateUsingScreenId(screenId: string, data: any, objectIdToSave?: string) {\r\n    let fields;\r\n    let appObject: any = AppObject;\r\n    let crudTableName;\r\n    if (screenId) {\r\n      const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n      const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);\r\n      fields = screenDataSource.Fields;\r\n      appObject = getAppObject(screenDataSource.ObjectID_Tosave);\r\n      crudTableName = appObject.SystemDBTableName;\r\n      syncAppObjectFields(data.data, appObject);\r\n    }\r\n    if (objectIdToSave) {\r\n      fields = [];\r\n      appObject = getAppObject(objectIdToSave);\r\n      appObject.Fields.forEach((element: any) => {\r\n        fields.push({ Field: element })\r\n      });\r\n      crudTableName = appObject.SystemDBTableName;\r\n      syncAppObjectFields(data.data, appObject);\r\n    }\r\n\r\n    const PrimaryKeyFields: any = getPrimaryKeyFields(appObject);\r\n    let whereClause: any = APIFilterCriteria;\r\n    if (appObject) {\r\n      if (data.data) {\r\n        const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);\r\n        data['recordId'] = recordId;\r\n\r\n        if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {\r\n          removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);\r\n          whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);\r\n        } else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {\r\n          whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);\r\n          removeMultiplePrimaryKey(data.data, PrimaryKeyFields);\r\n        }\r\n        const dataObj: any = createDynamicData(data.data);\r\n        removeBlankValue(dataObj);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(crudTableName, whereClause, dataObj);\r\n        return this.update(requestPayload);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  updateScreen(screenId: string, screenData: any) {\r\n    const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n    if (screen) {\r\n      const appObject = getAppObjectFromSystemDBTableName('TABMD_AppScreen');\r\n      if (appObject) {\r\n        syncAppObjectFields(screenData, appObject);\r\n      }\r\n      Object.assign({}, screen, { Container: screenData.Container });\r\n      const queryFilters: UpdateQueryParameter[] = [];\r\n      queryFilters.push({ FieldName: 'ID', FieldValue: screenId })\r\n      const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate('TABMD_AppScreen', queryFilters);\r\n      const dataObj: any = createDynamicData(screenData);\r\n      removeBlankValue(dataObj);\r\n      const requestPayload = this.requestResponseHelper.updateRequestPayload('TABMD_AppScreen', whereClause, dataObj);\r\n      return this.update(requestPayload);\r\n    }\r\n    return null;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/crud/tab-workflow.service.mjs

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable, inject } from "@angular/core";
+import { ApiService } from "../../core/http-client/api.service";
+import { getHeaders } from "../utils/req-res.util";
+import * as i0 from "@angular/core";
+export class TabWorkflowService {
+    constructor() {
+        this.apiService = inject(ApiService);
+    }
+    /**
+     * Executes a TAB workflow.
+     * @param endPoint The endpoint for the workflow.
+     * @param data The data to send with the request.
+     * @returns An observable of the workflow execution result.
+     */
+    executeTABWorkflow(endPoint, data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(endPoint, data, headers);
+        }
+        return null;
+    }
+    /**
+     * Executes an ELSA workflow.
+     * @param endPoint The endpoint for the workflow.
+     * @param data The data to send with the request.
+     * @returns An observable of the workflow execution result.
+     */
+    executeELSAWorkflow(endPoint, data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.postWorkflow(endPoint, data, headers);
+        }
+        return null;
+    }
+    static { this.ɵfac = function TabWorkflowService_Factory(t) { return new (t || TabWorkflowService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabWorkflowService, factory: TabWorkflowService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TabWorkflowService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/enums/controllers.enum.mjs

@@ -0,0 +1,26 @@
+export var DataTypes;
+(function (DataTypes) {
+    DataTypes[DataTypes["AutoNumber"] = 1] = "AutoNumber";
+    DataTypes[DataTypes["Number"] = 2] = "Number";
+    DataTypes[DataTypes["CheckBox"] = 3] = "CheckBox";
+    DataTypes[DataTypes["Currency"] = 4] = "Currency";
+    DataTypes[DataTypes["Date"] = 5] = "Date";
+    DataTypes[DataTypes["DateTime"] = 6] = "DateTime";
+    DataTypes[DataTypes["Email"] = 7] = "Email";
+    DataTypes[DataTypes["GeoLocation"] = 8] = "GeoLocation";
+    DataTypes[DataTypes["Percent"] = 9] = "Percent";
+    DataTypes[DataTypes["PhoneNumber"] = 10] = "PhoneNumber";
+    DataTypes[DataTypes["PickList"] = 11] = "PickList";
+    DataTypes[DataTypes["PickList_MultiSelect"] = 12] = "PickList_MultiSelect";
+    DataTypes[DataTypes["Text"] = 13] = "Text";
+    DataTypes[DataTypes["TextArea"] = 14] = "TextArea";
+    DataTypes[DataTypes["TextArea_RICHEDITOR"] = 15] = "TextArea_RICHEDITOR";
+    DataTypes[DataTypes["URL"] = 16] = "URL";
+    DataTypes[DataTypes["UniqueIdentifier"] = 17] = "UniqueIdentifier";
+    DataTypes[DataTypes["Insert_TimeStamp"] = 18] = "Insert_TimeStamp";
+    DataTypes[DataTypes["Update_TimeStamp"] = 19] = "Update_TimeStamp";
+    DataTypes[DataTypes["NextNumber"] = 20] = "NextNumber";
+    DataTypes[DataTypes["Array"] = 21] = "Array";
+    DataTypes[DataTypes["JSON"] = 22] = "JSON";
+})(DataTypes || (DataTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlcnMuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9lbnVtcy9jb250cm9sbGVycy5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFNBdUJYO0FBdkJELFdBQVksU0FBUztJQUNuQixxREFBYyxDQUFBO0lBQ2QsNkNBQVUsQ0FBQTtJQUNWLGlEQUFZLENBQUE7SUFDWixpREFBWSxDQUFBO0lBQ1oseUNBQVEsQ0FBQTtJQUNSLGlEQUFZLENBQUE7SUFDWiwyQ0FBUyxDQUFBO0lBQ1QsdURBQWUsQ0FBQTtJQUNmLCtDQUFXLENBQUE7SUFDWCx3REFBZ0IsQ0FBQTtJQUNoQixrREFBYSxDQUFBO0lBQ2IsMEVBQXlCLENBQUE7SUFDekIsMENBQVMsQ0FBQTtJQUNULGtEQUFhLENBQUE7SUFDYix3RUFBd0IsQ0FBQTtJQUN4Qix3Q0FBUSxDQUFBO0lBQ1Isa0VBQXFCLENBQUE7SUFDckIsa0VBQXFCLENBQUE7SUFDckIsa0VBQXFCLENBQUE7SUFDckIsc0RBQWUsQ0FBQTtJQUNmLDRDQUFVLENBQUE7SUFDViwwQ0FBUyxDQUFBO0FBQ1gsQ0FBQyxFQXZCVyxTQUFTLEtBQVQsU0FBUyxRQXVCcEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBEYXRhVHlwZXMge1xyXG4gIEF1dG9OdW1iZXIgPSAxLFxyXG4gIE51bWJlciA9IDIsXHJcbiAgQ2hlY2tCb3ggPSAzLFxyXG4gIEN1cnJlbmN5ID0gNCxcclxuICBEYXRlID0gNSxcclxuICBEYXRlVGltZSA9IDYsXHJcbiAgRW1haWwgPSA3LFxyXG4gIEdlb0xvY2F0aW9uID0gOCxcclxuICBQZXJjZW50ID0gOSxcclxuICBQaG9uZU51bWJlciA9IDEwLFxyXG4gIFBpY2tMaXN0ID0gMTEsXHJcbiAgUGlja0xpc3RfTXVsdGlTZWxlY3QgPSAxMixcclxuICBUZXh0ID0gMTMsXHJcbiAgVGV4dEFyZWEgPSAxNCxcclxuICBUZXh0QXJlYV9SSUNIRURJVE9SID0gMTUsXHJcbiAgVVJMID0gMTYsXHJcbiAgVW5pcXVlSWRlbnRpZmllciA9IDE3LFxyXG4gIEluc2VydF9UaW1lU3RhbXAgPSAxOCxcclxuICBVcGRhdGVfVGltZVN0YW1wID0gMTksXHJcbiAgTmV4dE51bWJlciA9IDIwLFxyXG4gIEFycmF5ID0gMjEsXHJcbiAgSlNPTiA9IDIyLFxyXG59XHJcbiJdfQ==

package/esm2022/lib/tab-core-utility/app/enums/dsq.enum.mjs

@@ -0,0 +1,48 @@
+export var ConjuctionClause;
+(function (ConjuctionClause) {
+    ConjuctionClause[ConjuctionClause["AND"] = 1] = "AND";
+    ConjuctionClause[ConjuctionClause["OR"] = 2] = "OR";
+    ConjuctionClause[ConjuctionClause["AND_NOT"] = 3] = "AND_NOT";
+    ConjuctionClause[ConjuctionClause["OR_NOT"] = 4] = "OR_NOT";
+})(ConjuctionClause || (ConjuctionClause = {}));
+export var RelationalOperator;
+(function (RelationalOperator) {
+    RelationalOperator[RelationalOperator["GreaterThan"] = 1] = "GreaterThan";
+    RelationalOperator[RelationalOperator["LessThan"] = 2] = "LessThan";
+    RelationalOperator[RelationalOperator["EqualTo"] = 3] = "EqualTo";
+    RelationalOperator[RelationalOperator["IN"] = 4] = "IN";
+    RelationalOperator[RelationalOperator["NOTIN"] = 5] = "NOTIN";
+    RelationalOperator[RelationalOperator["IsNULL"] = 6] = "IsNULL";
+    RelationalOperator[RelationalOperator["IsNotNULL"] = 7] = "IsNotNULL";
+    RelationalOperator[RelationalOperator["NotEqualTo"] = 8] = "NotEqualTo";
+    RelationalOperator[RelationalOperator["GreaterThanOREqualTo"] = 9] = "GreaterThanOREqualTo";
+    RelationalOperator[RelationalOperator["LessThanOREqualTo"] = 10] = "LessThanOREqualTo";
+    RelationalOperator[RelationalOperator["Contains"] = 11] = "Contains";
+    RelationalOperator[RelationalOperator["NotContains"] = 12] = "NotContains";
+    RelationalOperator[RelationalOperator["StartsWith"] = 13] = "StartsWith";
+    RelationalOperator[RelationalOperator["NotStartsWith"] = 14] = "NotStartsWith";
+    RelationalOperator[RelationalOperator["EndsWith"] = 15] = "EndsWith";
+    RelationalOperator[RelationalOperator["NotEndsWith"] = 16] = "NotEndsWith";
+    RelationalOperator[RelationalOperator["Between"] = 17] = "Between";
+    RelationalOperator[RelationalOperator["NotBetween"] = 18] = "NotBetween";
+    RelationalOperator[RelationalOperator["SplitContains"] = 19] = "SplitContains";
+    RelationalOperator[RelationalOperator["NotSplitContains"] = 20] = "NotSplitContains";
+})(RelationalOperator || (RelationalOperator = {}));
+export var FilterValueType;
+(function (FilterValueType) {
+    FilterValueType[FilterValueType["Literal"] = 1] = "Literal";
+    FilterValueType[FilterValueType["Parameter"] = 2] = "Parameter";
+    FilterValueType[FilterValueType["Property"] = 3] = "Property";
+    FilterValueType[FilterValueType["Global"] = 4] = "Global";
+})(FilterValueType || (FilterValueType = {}));
+export var SortSequence;
+(function (SortSequence) {
+    SortSequence[SortSequence["Asc"] = 1] = "Asc";
+    SortSequence[SortSequence["Desc"] = 2] = "Desc";
+})(SortSequence || (SortSequence = {}));
+export var ObjectCreationType;
+(function (ObjectCreationType) {
+    ObjectCreationType[ObjectCreationType["Standard"] = 1] = "Standard";
+    ObjectCreationType[ObjectCreationType["Custom"] = 2] = "Custom";
+})(ObjectCreationType || (ObjectCreationType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/enums/permission.enum.mjs

@@ -0,0 +1,20 @@
+export var AccessType;
+(function (AccessType) {
+    AccessType["READ"] = "READ";
+    AccessType["CREATE"] = "CREATE";
+    AccessType["UPDATE"] = "UPDATE";
+    AccessType["DELETE"] = "DELETE";
+})(AccessType || (AccessType = {}));
+export var AccessPermission;
+(function (AccessPermission) {
+    AccessPermission[AccessPermission["None"] = 1] = "None";
+    AccessPermission[AccessPermission["Own"] = 2] = "Own";
+    AccessPermission[AccessPermission["Team"] = 3] = "Team";
+    AccessPermission[AccessPermission["All"] = 4] = "All";
+})(AccessPermission || (AccessPermission = {}));
+export var DeploymentStatus;
+(function (DeploymentStatus) {
+    DeploymentStatus[DeploymentStatus["InDevelopment"] = 1] = "InDevelopment";
+    DeploymentStatus[DeploymentStatus["Deployed"] = 2] = "Deployed";
+})(DeploymentStatus || (DeploymentStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kYXRhLWFjY2Vzcy9zcmMvbGliL3RhYi1jb3JlLXV0aWxpdHkvYXBwL2VudW1zL3Blcm1pc3Npb24uZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxVQUtYO0FBTEQsV0FBWSxVQUFVO0lBQ3BCLDJCQUFhLENBQUE7SUFDYiwrQkFBaUIsQ0FBQTtJQUNqQiwrQkFBaUIsQ0FBQTtJQUNqQiwrQkFBaUIsQ0FBQTtBQUNuQixDQUFDLEVBTFcsVUFBVSxLQUFWLFVBQVUsUUFLckI7QUFFRCxNQUFNLENBQU4sSUFBWSxnQkFLWDtBQUxELFdBQVksZ0JBQWdCO0lBQzFCLHVEQUFRLENBQUE7SUFDUixxREFBTyxDQUFBO0lBQ1AsdURBQVEsQ0FBQTtJQUNSLHFEQUFPLENBQUE7QUFDVCxDQUFDLEVBTFcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQUszQjtBQUVELE1BQU0sQ0FBTixJQUFZLGdCQUdYO0FBSEQsV0FBWSxnQkFBZ0I7SUFDMUIseUVBQWlCLENBQUE7SUFDakIsK0RBQVksQ0FBQTtBQUNkLENBQUMsRUFIVyxnQkFBZ0IsS0FBaEIsZ0JBQWdCLFFBRzNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gQWNjZXNzVHlwZSB7XHJcbiAgUkVBRCA9ICdSRUFEJyxcclxuICBDUkVBVEUgPSAnQ1JFQVRFJyxcclxuICBVUERBVEUgPSAnVVBEQVRFJyxcclxuICBERUxFVEUgPSAnREVMRVRFJyxcclxufVxyXG5cclxuZXhwb3J0IGVudW0gQWNjZXNzUGVybWlzc2lvbiB7XHJcbiAgTm9uZSA9IDEsXHJcbiAgT3duID0gMixcclxuICBUZWFtID0gMyxcclxuICBBbGwgPSA0LFxyXG59XHJcblxyXG5leHBvcnQgZW51bSBEZXBsb3ltZW50U3RhdHVzIHtcclxuICBJbkRldmVsb3BtZW50ID0gMSxcclxuICBEZXBsb3llZCA9IDIsXHJcbn1cclxuIl19

package/esm2022/lib/tab-core-utility/app/enums/query.enum.mjs

@@ -0,0 +1,14 @@
+export var QueryType;
+(function (QueryType) {
+    QueryType[QueryType["Select"] = 0] = "Select";
+    QueryType[QueryType["Insert"] = 1] = "Insert";
+    QueryType[QueryType["Update"] = 2] = "Update";
+    QueryType[QueryType["Delete"] = 3] = "Delete";
+    QueryType[QueryType["Upsert"] = 4] = "Upsert";
+})(QueryType || (QueryType = {}));
+export var JoinType;
+(function (JoinType) {
+    JoinType[JoinType["LeftJoin"] = 1] = "LeftJoin";
+    JoinType[JoinType["RightJoin"] = 2] = "RightJoin";
+})(JoinType || (JoinType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9lbnVtcy9xdWVyeS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFNBTVg7QUFORCxXQUFZLFNBQVM7SUFDbkIsNkNBQU0sQ0FBQTtJQUNOLDZDQUFNLENBQUE7SUFDTiw2Q0FBTSxDQUFBO0lBQ04sNkNBQU0sQ0FBQTtJQUNOLDZDQUFNLENBQUE7QUFDUixDQUFDLEVBTlcsU0FBUyxLQUFULFNBQVMsUUFNcEI7QUFFRCxNQUFNLENBQU4sSUFBWSxRQUdYO0FBSEQsV0FBWSxRQUFRO0lBQ2xCLCtDQUFZLENBQUE7SUFDWixpREFBYSxDQUFBO0FBQ2YsQ0FBQyxFQUhXLFFBQVEsS0FBUixRQUFRLFFBR25CIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUXVlcnlUeXBlIHtcclxuICBTZWxlY3QsXHJcbiAgSW5zZXJ0LFxyXG4gIFVwZGF0ZSxcclxuICBEZWxldGUsXHJcbiAgVXBzZXJ0LFxyXG59XHJcblxyXG5leHBvcnQgZW51bSBKb2luVHlwZSB7XHJcbiAgTGVmdEpvaW4gPSAxLFxyXG4gIFJpZ2h0Sm9pbiA9IDIsXHJcbn1cclxuIl19

package/esm2022/lib/tab-core-utility/app/enums/workflow.enum.mjs

@@ -0,0 +1,37 @@
+export var WorkFlowTriggerType;
+(function (WorkFlowTriggerType) {
+    WorkFlowTriggerType[WorkFlowTriggerType["EventBased"] = 1] = "EventBased";
+    WorkFlowTriggerType[WorkFlowTriggerType["DateBased"] = 2] = "DateBased";
+})(WorkFlowTriggerType || (WorkFlowTriggerType = {}));
+export var WorkFlowEventExecution_WorkFlowTriggerEvent;
+(function (WorkFlowEventExecution_WorkFlowTriggerEvent) {
+    WorkFlowEventExecution_WorkFlowTriggerEvent[WorkFlowEventExecution_WorkFlowTriggerEvent["Created"] = 1] = "Created";
+    WorkFlowEventExecution_WorkFlowTriggerEvent[WorkFlowEventExecution_WorkFlowTriggerEvent["Edited"] = 2] = "Edited";
+    WorkFlowEventExecution_WorkFlowTriggerEvent[WorkFlowEventExecution_WorkFlowTriggerEvent["CreatedOrEdited"] = 3] = "CreatedOrEdited";
+    WorkFlowEventExecution_WorkFlowTriggerEvent[WorkFlowEventExecution_WorkFlowTriggerEvent["Deleted"] = 4] = "Deleted";
+})(WorkFlowEventExecution_WorkFlowTriggerEvent || (WorkFlowEventExecution_WorkFlowTriggerEvent = {}));
+export var WorkFlowEventExecution_WorkFlowTriggerFieldCriteria;
+(function (WorkFlowEventExecution_WorkFlowTriggerFieldCriteria) {
+    WorkFlowEventExecution_WorkFlowTriggerFieldCriteria[WorkFlowEventExecution_WorkFlowTriggerFieldCriteria["WhenAnyFieldIsUpdated"] = 1] = "WhenAnyFieldIsUpdated";
+    WorkFlowEventExecution_WorkFlowTriggerFieldCriteria[WorkFlowEventExecution_WorkFlowTriggerFieldCriteria["WhenAnySelectedFieldIsUpdated"] = 2] = "WhenAnySelectedFieldIsUpdated";
+    WorkFlowEventExecution_WorkFlowTriggerFieldCriteria[WorkFlowEventExecution_WorkFlowTriggerFieldCriteria["WhenSelectedAllFieldsAreUpdated"] = 3] = "WhenSelectedAllFieldsAreUpdated";
+})(WorkFlowEventExecution_WorkFlowTriggerFieldCriteria || (WorkFlowEventExecution_WorkFlowTriggerFieldCriteria = {}));
+export var WorkFlowEventExecution_WorkFlowTriggerOccurence;
+(function (WorkFlowEventExecution_WorkFlowTriggerOccurence) {
+    WorkFlowEventExecution_WorkFlowTriggerOccurence[WorkFlowEventExecution_WorkFlowTriggerOccurence["Everytime"] = 1] = "Everytime";
+    WorkFlowEventExecution_WorkFlowTriggerOccurence[WorkFlowEventExecution_WorkFlowTriggerOccurence["FirstTime"] = 2] = "FirstTime";
+})(WorkFlowEventExecution_WorkFlowTriggerOccurence || (WorkFlowEventExecution_WorkFlowTriggerOccurence = {}));
+export var WorkFlowTimeExecution_DaysRelationalOperator;
+(function (WorkFlowTimeExecution_DaysRelationalOperator) {
+    WorkFlowTimeExecution_DaysRelationalOperator[WorkFlowTimeExecution_DaysRelationalOperator["Before"] = 1] = "Before";
+    WorkFlowTimeExecution_DaysRelationalOperator[WorkFlowTimeExecution_DaysRelationalOperator["After"] = 2] = "After";
+})(WorkFlowTimeExecution_DaysRelationalOperator || (WorkFlowTimeExecution_DaysRelationalOperator = {}));
+export var WorkFlowTimeExecution_ExecutionCycle;
+(function (WorkFlowTimeExecution_ExecutionCycle) {
+    WorkFlowTimeExecution_ExecutionCycle[WorkFlowTimeExecution_ExecutionCycle["Once"] = 1] = "Once";
+    WorkFlowTimeExecution_ExecutionCycle[WorkFlowTimeExecution_ExecutionCycle["Weekly"] = 2] = "Weekly";
+    WorkFlowTimeExecution_ExecutionCycle[WorkFlowTimeExecution_ExecutionCycle["Monthly"] = 3] = "Monthly";
+    WorkFlowTimeExecution_ExecutionCycle[WorkFlowTimeExecution_ExecutionCycle["Yearly"] = 4] = "Yearly";
+    WorkFlowTimeExecution_ExecutionCycle[WorkFlowTimeExecution_ExecutionCycle["Daily"] = 5] = "Daily";
+})(WorkFlowTimeExecution_ExecutionCycle || (WorkFlowTimeExecution_ExecutionCycle = {}));
+//# sourceMappingURL=data:application/json;base64,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