@techextensor/tab-core-utility 2.1.7 → 2.1.8

package/esm2022/lib/tab-core-utility/app/helpers/common/where-clause.helpers.mjs

@@ -0,0 +1,208 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { filter, map, toArray } from 'rxjs/operators';
+import { ConjuctionClause, RelationalOperator, FilterValueType, } from '../../enums/dsq.enum';
+import { APIFilterCriteria } from '../../models/api-query.class';
+import { getAppObjectFromSystemDBTableName, getAppObject, } from '../../utils/tab-app.util';
+import * as i0 from "@angular/core";
+export class WhereClauseHelper {
+    /**
+     * Binds the where clause for deleting records based on field, value, field name, and CRUD table name
+     * @param fields The fields to bind the where clause
+     * @param value The value to match in the where clause
+     * @param fieldName The field name to match in the where clause
+     * @param crudTableName The CRUD table name for the where clause
+     * @returns The bound where clause for delete operation
+     */
+    bindWhereClauseForDelete(fields, value, fieldName, crudTableName) {
+        const appobj = getAppObjectFromSystemDBTableName(crudTableName);
+        if (appobj && appobj.CRUDAppObjectId !== null) {
+            const crudAppObj = getAppObject(appobj.CRUDAppObjectId);
+            if (crudAppObj) {
+                crudTableName = crudAppObj.SystemDBTableName;
+            }
+        }
+        return this.bindWhereClause(fields, value, fieldName, crudTableName);
+    }
+    /**
+     * Binds the where clause for deleting records with multiple primary keys
+     * @param data The data containing primary key values
+     * @param fieldName The field name of the primary key
+     * @param crudTableName The CRUD table name for the where clause
+     * @returns The bound where clause for delete operation with multiple primary keys
+     */
+    bindWhereClauseForDeleteWithMultiplePrimaryKeys(data, fieldName, crudTableName) {
+        return this.bindWhereClauseForMultiplePrimaryKeys(data, fieldName, crudTableName);
+    }
+    /**
+     * Binds the where clause for an insert operation
+     * @returns The bound where clause for insert operation
+     */
+    bindWhereClauseForInsert() {
+        return this.bindWhereClauseEmpty();
+    }
+    /**
+     * Binds an empty where clause
+     * @returns The bound empty where clause
+     */
+    bindWhereClauseEmpty() {
+        const whereClause = new APIFilterCriteria();
+        whereClause.FilterLogic = '1';
+        whereClause.Filters = [];
+        return whereClause;
+    }
+    /**
+     * Binds the where clause based on provided parameters
+     * @param fields The fields to bind the where clause
+     * @param value The value to match in the where clause
+     * @param fieldName The field name to match in the where clause
+     * @param crudTableName The CRUD table name for the where clause
+     * @returns The bound where clause
+     */
+    bindWhereClause(fields, value, fieldName, crudTableName) {
+        return from(fields).pipe(filter((f) => fieldName
+            ? f.Field?.FieldName === fieldName
+            : f.Field?.FieldName === 'Id' || f.Field?.FieldName === 'ID'), map((field) => ({
+            ConjuctionClause: ConjuctionClause.AND,
+            FieldID: crudTableName + '.' + field.Field.SystemDBFieldName,
+            RelationalOperator: RelationalOperator.EqualTo,
+            ValueType: FilterValueType.Literal,
+            value: value,
+            Sequence: 0,
+            GroupID: 0,
+        })), toArray(), map((filters) => {
+            const whereClause = new APIFilterCriteria();
+            whereClause.Filters = filters;
+            whereClause.FilterLogic = '1';
+            return whereClause;
+        }));
+    }
+    /**
+     * Binds the where clause for deleting records with multiple primary keys
+     * @param data The data containing primary key values
+     * @param primaryKeys The array of primary key fields
+     * @param crudTableName The CRUD table name for the where clause
+     * @returns The bound where clause for delete operation with multiple primary keys
+     */
+    bindWhereClauseForMultiplePrimaryKeys(data, primaryKeys, crudTableName) {
+        const whereClause = new APIFilterCriteria();
+        whereClause.Filters = [];
+        if (primaryKeys && primaryKeys.length > 0) {
+            primaryKeys.forEach((element) => {
+                const value = data[element.FieldName];
+                if (value) {
+                    const filter = {
+                        ConjuctionClause: ConjuctionClause.AND,
+                        FieldID: crudTableName + '.' + element.SystemDBFieldName,
+                        RelationalOperator: RelationalOperator.EqualTo,
+                        ValueType: FilterValueType.Literal,
+                        value: value,
+                        Sequence: 0,
+                        GroupID: 0,
+                    };
+                    whereClause.Filters.push(filter);
+                }
+            });
+        }
+        whereClause.FilterLogic = '1';
+        return whereClause;
+    }
+    /**
+     * Binds the where clause for updating records
+     * @param tableName The name of the table to update
+     * @param queryFieldsArray The array of fields and values for the update query
+     * @returns The bound where clause for update operation
+     */
+    bindWhereClauseForUpdate(tableName, queryFieldsArray) {
+        const whereClause = new APIFilterCriteria();
+        whereClause.Filters = [];
+        if (queryFieldsArray.length) {
+            queryFieldsArray.forEach((element) => {
+                const filter = {
+                    ConjuctionClause: ConjuctionClause.AND,
+                    FieldID: tableName + '.' + element.FieldName,
+                    RelationalOperator: RelationalOperator.EqualTo,
+                    ValueType: FilterValueType.Literal,
+                    value: element.FieldValue,
+                    Sequence: 0,
+                    GroupID: 0,
+                };
+                whereClause.Filters.push(filter);
+            });
+        }
+        whereClause.FilterLogic = '1';
+        return whereClause;
+    }
+    /**
+     * Binds the where clause for deleting records by table and primary key
+     * @param tableName The name of the table from which to delete records
+     * @param primaryKey The name of the primary key field
+     * @param primaryKeyValue The value of the primary key
+     * @returns The bound where clause for delete operation using table and primary key
+     */
+    bindWhereClauseForDeleteByTable(tableName, primaryKey, primaryKeyValue) {
+        const whereClause = new APIFilterCriteria();
+        whereClause.Filters = [];
+        const filter = {
+            ConjuctionClause: ConjuctionClause.AND,
+            FieldID: tableName + '.' + primaryKey,
+            RelationalOperator: RelationalOperator.EqualTo,
+            ValueType: FilterValueType.Literal,
+            value: primaryKeyValue,
+            Sequence: 0,
+            GroupID: 0,
+        };
+        whereClause.Filters.push(filter);
+        whereClause.FilterLogic = '1';
+        return whereClause;
+    }
+    /**
+     * Binds the where clause for deleting records using IN operator by table
+     * @param tableName The name of the table from which to delete records
+     * @param primaryKey The name of the primary key field
+     * @param values The array of values for the IN operator
+     * @returns The bound where clause for delete operation using IN operator and table
+     */
+    bindWhereClauseForDeleteUsingInOperatorByTable(tableName, primaryKey, values) {
+        const appobj = getAppObjectFromSystemDBTableName(tableName);
+        if (appobj?.CRUDAppObjectId !== null) {
+            const crudAppObj = getAppObject(appobj.CRUDAppObjectId);
+            if (crudAppObj) {
+                tableName = crudAppObj.SystemDBTableName;
+            }
+        }
+        const whereClause = new APIFilterCriteria();
+        whereClause.Filters = [];
+        const filter = {
+            ConjuctionClause: ConjuctionClause.AND,
+            FieldID: tableName + '.' + primaryKey,
+            RelationalOperator: RelationalOperator.IN,
+            ValueType: FilterValueType.Literal,
+            value: values.join(','),
+            Sequence: 0,
+            GroupID: 0,
+        };
+        whereClause.Filters.push(filter);
+        whereClause.FilterLogic = '1';
+        return whereClause;
+    }
+    /**
+     * Binds the where clause for updating records in a grid
+     * @param Fields The fields to bind the where clause
+     * @param value The value to match in the where clause
+     * @param fieldName The field name to match in the where clause
+     * @param crudTableName The CRUD table name for the where clause
+     * @returns The bound where clause for update operation in a grid
+     */
+    bindWhereClauseForUpdateGrid(Fields, value, fieldName, crudTableName) {
+        return this.bindWhereClause(Fields, value, fieldName, crudTableName);
+    }
+    static { this.ɵfac = function WhereClauseHelper_Factory(t) { return new (t || WhereClauseHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WhereClauseHelper, factory: WhereClauseHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WhereClauseHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"where-clause.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/where-clause.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { from } from 'rxjs';\r\nimport { filter, map, toArray } from 'rxjs/operators';\r\n\r\nimport {\r\n  ConjuctionClause,\r\n  RelationalOperator,\r\n  FilterValueType,\r\n} from '../../enums/dsq.enum';\r\nimport { APIFilterCriteria } from '../../models/api-query.class';\r\nimport {\r\n  getAppObjectFromSystemDBTableName,\r\n  getAppObject,\r\n} from '../../utils/tab-app.util';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class WhereClauseHelper {\r\n  /**\r\n   * Binds the where clause for deleting records based on field, value, field name, and CRUD table name\r\n   * @param fields The fields to bind the where clause\r\n   * @param value The value to match in the where clause\r\n   * @param fieldName The field name to match in the where clause\r\n   * @param crudTableName The CRUD table name for the where clause\r\n   * @returns The bound where clause for delete operation\r\n   */\r\n  bindWhereClauseForDelete(\r\n    fields: any,\r\n    value: any,\r\n    fieldName: string,\r\n    crudTableName: string\r\n  ) {\r\n    const appobj = getAppObjectFromSystemDBTableName(crudTableName);\r\n    if (appobj && appobj.CRUDAppObjectId !== null) {\r\n      const crudAppObj = getAppObject(appobj.CRUDAppObjectId);\r\n      if (crudAppObj) {\r\n        crudTableName = crudAppObj.SystemDBTableName;\r\n      }\r\n    }\r\n    return this.bindWhereClause(fields, value, fieldName, crudTableName);\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for deleting records with multiple primary keys\r\n   * @param data The data containing primary key values\r\n   * @param fieldName The field name of the primary key\r\n   * @param crudTableName The CRUD table name for the where clause\r\n   * @returns The bound where clause for delete operation with multiple primary keys\r\n   */\r\n  bindWhereClauseForDeleteWithMultiplePrimaryKeys(\r\n    data: any,\r\n    fieldName: string,\r\n    crudTableName: string\r\n  ) {\r\n    return this.bindWhereClauseForMultiplePrimaryKeys(\r\n      data,\r\n      fieldName,\r\n      crudTableName\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for an insert operation\r\n   * @returns The bound where clause for insert operation\r\n   */\r\n  bindWhereClauseForInsert() {\r\n    return this.bindWhereClauseEmpty();\r\n  }\r\n\r\n  /**\r\n   * Binds an empty where clause\r\n   * @returns The bound empty where clause\r\n   */\r\n  bindWhereClauseEmpty() {\r\n    const whereClause = new APIFilterCriteria();\r\n    whereClause.FilterLogic = '1';\r\n    whereClause.Filters = [];\r\n    return whereClause;\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause based on provided parameters\r\n   * @param fields The fields to bind the where clause\r\n   * @param value The value to match in the where clause\r\n   * @param fieldName The field name to match in the where clause\r\n   * @param crudTableName The CRUD table name for the where clause\r\n   * @returns The bound where clause\r\n   */\r\n  private bindWhereClause(\r\n    fields: any,\r\n    value: any,\r\n    fieldName: string,\r\n    crudTableName: string\r\n  ) {\r\n    return from(fields).pipe(\r\n      filter((f: any) =>\r\n        fieldName\r\n          ? f.Field?.FieldName === fieldName\r\n          : f.Field?.FieldName === 'Id' || f.Field?.FieldName === 'ID'\r\n      ),\r\n      map((field: any) => ({\r\n        ConjuctionClause: ConjuctionClause.AND,\r\n        FieldID: crudTableName + '.' + field.Field.SystemDBFieldName,\r\n        RelationalOperator: RelationalOperator.EqualTo,\r\n        ValueType: FilterValueType.Literal,\r\n        value: value,\r\n        Sequence: 0,\r\n        GroupID: 0,\r\n      })),\r\n      toArray(),\r\n      map((filters: any[]) => {\r\n        const whereClause = new APIFilterCriteria();\r\n        whereClause.Filters = filters;\r\n        whereClause.FilterLogic = '1';\r\n        return whereClause;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for deleting records with multiple primary keys\r\n   * @param data The data containing primary key values\r\n   * @param primaryKeys The array of primary key fields\r\n   * @param crudTableName The CRUD table name for the where clause\r\n   * @returns The bound where clause for delete operation with multiple primary keys\r\n   */\r\n  bindWhereClauseForMultiplePrimaryKeys(\r\n    data: any,\r\n    primaryKeys: any,\r\n    crudTableName: string\r\n  ) {\r\n    const whereClause = new APIFilterCriteria();\r\n    whereClause.Filters = [];\r\n    if (primaryKeys && primaryKeys.length > 0) {\r\n      primaryKeys.forEach((element: any) => {\r\n        const value = data[element.FieldName];\r\n        if (value) {\r\n          const filter: any = {\r\n            ConjuctionClause: ConjuctionClause.AND,\r\n            FieldID: crudTableName + '.' + element.SystemDBFieldName,\r\n            RelationalOperator: RelationalOperator.EqualTo,\r\n            ValueType: FilterValueType.Literal,\r\n            value: value,\r\n            Sequence: 0,\r\n            GroupID: 0,\r\n          };\r\n          whereClause.Filters.push(filter);\r\n        }\r\n      });\r\n    }\r\n    whereClause.FilterLogic = '1';\r\n    return whereClause;\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for updating records\r\n   * @param tableName The name of the table to update\r\n   * @param queryFieldsArray The array of fields and values for the update query\r\n   * @returns The bound where clause for update operation\r\n   */\r\n  bindWhereClauseForUpdate(tableName: string, queryFieldsArray: any) {\r\n    const whereClause = new APIFilterCriteria();\r\n    whereClause.Filters = [];\r\n    if (queryFieldsArray.length) {\r\n      queryFieldsArray.forEach((element: any) => {\r\n        const filter: any = {\r\n          ConjuctionClause: ConjuctionClause.AND,\r\n          FieldID: tableName + '.' + element.FieldName,\r\n          RelationalOperator: RelationalOperator.EqualTo,\r\n          ValueType: FilterValueType.Literal,\r\n          value: element.FieldValue,\r\n          Sequence: 0,\r\n          GroupID: 0,\r\n        };\r\n        whereClause.Filters.push(filter);\r\n      });\r\n    }\r\n    whereClause.FilterLogic = '1';\r\n    return whereClause;\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for deleting records by table and primary key\r\n   * @param tableName The name of the table from which to delete records\r\n   * @param primaryKey The name of the primary key field\r\n   * @param primaryKeyValue The value of the primary key\r\n   * @returns The bound where clause for delete operation using table and primary key\r\n   */\r\n  bindWhereClauseForDeleteByTable(\r\n    tableName: string,\r\n    primaryKey: string,\r\n    primaryKeyValue: string\r\n  ) {\r\n    const whereClause = new APIFilterCriteria();\r\n    whereClause.Filters = [];\r\n    const filter: any = {\r\n      ConjuctionClause: ConjuctionClause.AND,\r\n      FieldID: tableName + '.' + primaryKey,\r\n      RelationalOperator: RelationalOperator.EqualTo,\r\n      ValueType: FilterValueType.Literal,\r\n      value: primaryKeyValue,\r\n      Sequence: 0,\r\n      GroupID: 0,\r\n    };\r\n    whereClause.Filters.push(filter);\r\n    whereClause.FilterLogic = '1';\r\n    return whereClause;\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for deleting records using IN operator by table\r\n   * @param tableName The name of the table from which to delete records\r\n   * @param primaryKey The name of the primary key field\r\n   * @param values The array of values for the IN operator\r\n   * @returns The bound where clause for delete operation using IN operator and table\r\n   */\r\n  bindWhereClauseForDeleteUsingInOperatorByTable(\r\n    tableName: string,\r\n    primaryKey: string,\r\n    values: []\r\n  ) {\r\n    const appobj = getAppObjectFromSystemDBTableName(tableName);\r\n    if (appobj?.CRUDAppObjectId !== null) {\r\n      const crudAppObj = getAppObject(appobj.CRUDAppObjectId);\r\n      if (crudAppObj) {\r\n        tableName = crudAppObj.SystemDBTableName;\r\n      }\r\n    }\r\n    const whereClause = new APIFilterCriteria();\r\n    whereClause.Filters = [];\r\n    const filter: any = {\r\n      ConjuctionClause: ConjuctionClause.AND,\r\n      FieldID: tableName + '.' + primaryKey,\r\n      RelationalOperator: RelationalOperator.IN,\r\n      ValueType: FilterValueType.Literal,\r\n      value: values.join(','),\r\n      Sequence: 0,\r\n      GroupID: 0,\r\n    };\r\n    whereClause.Filters.push(filter);\r\n    whereClause.FilterLogic = '1';\r\n    return whereClause;\r\n  }\r\n\r\n  /**\r\n   * Binds the where clause for updating records in a grid\r\n   * @param Fields The fields to bind the where clause\r\n   * @param value The value to match in the where clause\r\n   * @param fieldName The field name to match in the where clause\r\n   * @param crudTableName The CRUD table name for the where clause\r\n   * @returns The bound where clause for update operation in a grid\r\n   */\r\n  bindWhereClauseForUpdateGrid(\r\n    Fields: any,\r\n    value: any,\r\n    fieldName: string,\r\n    crudTableName: string\r\n  ) {\r\n    return this.bindWhereClause(Fields, value, fieldName, crudTableName);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/helpers/screen/forms.helpers.mjs

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormDataHelper {
+    /**
+   * Sets form data based on the provided data object.
+   * @param data$ An Observable emitting the data object containing form data.
+   * @returns An Observable emitting an object containing the modified form data.
+   */
+    setFormData(data) {
+        const objNew = {};
+        if (!!data && !!data.Result) {
+            Object.entries(data.Result[0]).forEach(([key, value]) => {
+                if (key !== undefined) {
+                    if (typeof value === 'number') {
+                        value = value.toString();
+                    }
+                    if (key == 'Logo') {
+                        if (value !== '' && value !== null && value !== undefined) {
+                            // Additional handling can be added here if necessary
+                        }
+                    }
+                    else {
+                        objNew[key] = value;
+                    }
+                }
+            });
+        }
+        return objNew;
+    }
+    static { this.ɵfac = function FormDataHelper_Factory(t) { return new (t || FormDataHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormDataHelper, factory: FormDataHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormDataHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/helpers/screen/grid-column-data.helpers.mjs

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable, inject } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { GridHelper } from './grid.helpers';
+import * as i0 from "@angular/core";
+export class GridColumnDataHelper {
+    constructor() {
+        this.gridHelper = inject(GridHelper);
+        /**
+         * Renderer function for rendering row links.
+         * @param row The row number.
+         * @param column The column information.
+         * @param value The value to render.
+         * @returns The HTML string for rendering the row link.
+         */
+        this.rowLinkRenderer = (row, column, value) => {
+            return `&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <a data-row='${row}' style='cursor:pointer;' column-name='${column}' action='redirect' class='Link_click' >${value}</a>`;
+        };
+    }
+    /**
+     * Retrieves column data based on the provided fields.
+     * @param fields The fields to generate column data from.
+     * @returns An Observable emitting an array of column data.
+     */
+    getColumnData(fields) {
+        return of(fields).pipe(map((fields) => {
+            return fields.map((field) => this.mapToColumnDetailModel(field));
+        }));
+    }
+    /**
+     * Maps field data to a ColumnDetailModel.
+     * @param field The field data to map.
+     * @returns The mapped ColumnDetailModel.
+     */
+    mapToColumnDetailModel(field) {
+        const columnD = {
+            text: field?.Field?.DisplayName,
+            dataField: field?.Field?.FieldName,
+            columntype: this.gridHelper.getColumnType(field?.Field?.FieldType?.DataType),
+            appFieldId: field?.Field?.ID,
+            seq: field?.SeqNo,
+            isPrimaryKey: field?.Field?.IsPrimaryKey,
+            SystemDBFieldName: field?.Field?.SystemDBFieldName,
+        };
+        if (field?.FieldType == 2) {
+            columnD.dataField = field?.LookupDetails?.replaceAll('.', '_');
+            columnD.dataField = field?.FieldDetails?.replaceAll('.', '_');
+        }
+        if (field && field?.Field_GridAttributes) {
+            const attr = JSON.parse(field?.Field_GridAttributes);
+            Object.assign(columnD, attr);
+            if (!!attr.cellsrenderer && attr.cellsrenderer !== '') {
+                columnD.cellsrenderer = this.getRendererValue(attr.cellsrenderer);
+            }
+        }
+        if (field && field?.Field?.LookUpDetails) {
+            columnD.LookUpDetails = field?.Field?.LookUpDetails;
+            columnD.dropDownLookup = field?.Field?.dropDownData;
+        }
+        return columnD;
+    }
+    /**
+     * Retrieves the renderer value based on the provided key.
+     * @param key The key to retrieve the renderer value for.
+     * @returns The renderer value.
+     */
+    getRendererValue(key) {
+        return key && key === 'LINKRENDERER' ? this.rowLinkRenderer : null;
+    }
+    static { this.ɵfac = function GridColumnDataHelper_Factory(t) { return new (t || GridColumnDataHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GridColumnDataHelper, factory: GridColumnDataHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GridColumnDataHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/helpers/screen/grid.helpers.mjs

@@ -0,0 +1,112 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import { getDsqIDFromQueryName } from '../../utils/tab-app.util';
+import { of } from 'rxjs';
+import { Common } from '../../constants/common';
+import * as i0 from "@angular/core";
+export class GridHelper {
+    /**
+     * Generates a grid schema for the master app object.
+     * @param masterAppObj The master app object.
+     * @param dsqID The data source query ID.
+     * @returns The generated grid schema.
+     */
+    generateGridSchema(masterAppObj, dsqID) {
+        const schema = {
+            label: masterAppObj?.SystemDBTableName,
+            type: 'customGrid',
+            key: masterAppObj?.SystemDBTableName,
+            input: true,
+            redrawOn: masterAppObj?.SystemDBTableName,
+            'customOptions.dataSourceQueryId': dsqID,
+        };
+        return schema;
+    }
+    /**
+     * Generates a grid schema for the child relationship.
+     * @param childRel The child relationship.
+     * @param masterAppObj The master app object.
+     * @returns The generated child grid schema.
+     */
+    generateChildGridSchema(childRel, masterAppObj) {
+        const dsqNameString = 'FK_' +
+            childRel.childDetails.LookupObject +
+            '_' +
+            masterAppObj.SystemDBTableName;
+        const dsqObject = getDsqIDFromQueryName(childRel.childDetails.LookupObject, dsqNameString);
+        if (dsqObject) {
+            return {
+                label: childRel?.childDetails?.LookupObject,
+                type: 'customGrid',
+                key: childRel?.childDetails?.LookupObject,
+                input: true,
+                redrawOn: masterAppObj?.SystemDBTableName,
+                'customOptions.dataSourceQueryId': dsqObject ? dsqObject.ID : '',
+                logic: [
+                    {
+                        name: 'Update Fields',
+                        trigger: {
+                            type: 'javascript',
+                            javascript: 'result=true;',
+                        },
+                        actions: [
+                            {
+                                name: 'Refresh ' + childRel?.childDetails?.LookupObject + ' Grid',
+                                type: 'property',
+                                property: {
+                                    label: 'parameters',
+                                    value: 'customOptions.parameters',
+                                    type: 'string',
+                                },
+                                text: '{{data.' + masterAppObj?.SystemDBTableName + '}}',
+                            },
+                        ],
+                    },
+                ],
+            };
+        }
+        return of({});
+    }
+    /**
+     * Retrieves the default grid configuration.
+     * @returns The default grid configuration.
+     */
+    getDefaultGridConfiguration() {
+        const tabData = Common.tabJson;
+        if (tabData) {
+            const configuration = tabData?.AppConfigurations.find((c) => c.Setting_Key === 'GridConfig');
+            if (configuration) {
+                return JSON.parse(configuration.Value);
+            }
+        }
+        return null;
+    }
+    /**
+     * Determines the column type based on the data type.
+     * @param dataType The data type.
+     * @returns The column type.
+     */
+    getColumnType(dataType) {
+        if (dataType === 1 || (dataType >= 7 && dataType === 15))
+            return 'string';
+        else if (dataType === 2 || dataType === 4 || dataType === 16)
+            return 'number';
+        else if (dataType === 3)
+            return 'boolean';
+        else if (dataType === 4 || (dataType >= 7 && dataType <= 15))
+            return 'string';
+        else if (dataType === 5)
+            return 'date';
+        else if (dataType === 6)
+            return 'dateTime';
+        else
+            return 'string';
+    }
+    static { this.ɵfac = function GridHelper_Factory(t) { return new (t || GridHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GridHelper, factory: GridHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GridHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/screen/grid.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable } from '@angular/core';\r\nimport { AppObject } from '../../models/app-object.class';\r\nimport { getDsqIDFromQueryName } from '../../utils/tab-app.util';\r\nimport { of } from 'rxjs';\r\nimport { Common } from '../../constants/common';\r\nimport { JqWidghtModel } from '../../interfaces/grid.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class GridHelper {\r\n  /**\r\n   * Generates a grid schema for the master app object.\r\n   * @param masterAppObj The master app object.\r\n   * @param dsqID The data source query ID.\r\n   * @returns The generated grid schema.\r\n   */\r\n  generateGridSchema(masterAppObj: AppObject, dsqID: any) {\r\n    const schema = {\r\n      label: masterAppObj?.SystemDBTableName,\r\n      type: 'customGrid',\r\n      key: masterAppObj?.SystemDBTableName,\r\n      input: true,\r\n      redrawOn: masterAppObj?.SystemDBTableName,\r\n      'customOptions.dataSourceQueryId': dsqID,\r\n    };\r\n    return schema;\r\n  }\r\n\r\n  /**\r\n   * Generates a grid schema for the child relationship.\r\n   * @param childRel The child relationship.\r\n   * @param masterAppObj The master app object.\r\n   * @returns The generated child grid schema.\r\n   */\r\n  generateChildGridSchema(childRel: any, masterAppObj: AppObject) {\r\n    const dsqNameString =\r\n      'FK_' +\r\n      childRel.childDetails.LookupObject +\r\n      '_' +\r\n      masterAppObj.SystemDBTableName;\r\n    const dsqObject = getDsqIDFromQueryName(\r\n      childRel.childDetails.LookupObject,\r\n      dsqNameString\r\n    );\r\n    if (dsqObject) {\r\n      return {\r\n        label: childRel?.childDetails?.LookupObject,\r\n        type: 'customGrid',\r\n        key: childRel?.childDetails?.LookupObject,\r\n        input: true,\r\n        redrawOn: masterAppObj?.SystemDBTableName,\r\n        'customOptions.dataSourceQueryId': dsqObject ? dsqObject.ID : '',\r\n        logic: [\r\n          {\r\n            name: 'Update Fields',\r\n            trigger: {\r\n              type: 'javascript',\r\n              javascript: 'result=true;',\r\n            },\r\n            actions: [\r\n              {\r\n                name:\r\n                  'Refresh ' + childRel?.childDetails?.LookupObject + ' Grid',\r\n                type: 'property',\r\n                property: {\r\n                  label: 'parameters',\r\n                  value: 'customOptions.parameters',\r\n                  type: 'string',\r\n                },\r\n                text: '{{data.' + masterAppObj?.SystemDBTableName + '}}',\r\n              },\r\n            ],\r\n          },\r\n        ],\r\n      };\r\n    }\r\n    return of({});\r\n  }\r\n\r\n  /**\r\n   * Retrieves the default grid configuration.\r\n   * @returns The default grid configuration.\r\n   */\r\n  getDefaultGridConfiguration(): JqWidghtModel | null {\r\n    const tabData: any = Common.tabJson;\r\n    if (tabData) {\r\n      const configuration = tabData?.AppConfigurations.find(\r\n        (c: any) => c.Setting_Key === 'GridConfig'\r\n      );\r\n      if (configuration) {\r\n        return JSON.parse(configuration.Value);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Determines the column type based on the data type.\r\n   * @param dataType The data type.\r\n   * @returns The column type.\r\n   */\r\n  getColumnType(dataType: number): string {\r\n    if (dataType === 1 || (dataType >= 7 && dataType === 15)) return 'string';\r\n    else if (dataType === 2 || dataType === 4 || dataType === 16)\r\n      return 'number';\r\n    else if (dataType === 3) return 'boolean';\r\n    else if (dataType === 4 || (dataType >= 7 && dataType <= 15))\r\n      return 'string';\r\n    else if (dataType === 5) return 'date';\r\n    else if (dataType === 6) return 'dateTime';\r\n    else return 'string';\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/helpers/screen/media-upload.helpers.mjs

@@ -0,0 +1,77 @@
+/* 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 { of } from 'rxjs';
+import { API } from '../../constants/api-constants';
+import * as i0 from "@angular/core";
+export class MediaUploadHelper {
+    constructor() {
+        this.apiService = inject(ApiService);
+    }
+    /**
+     * Uploads media object to the server.
+     * @param mediaObject The media object to upload.
+     * @returns An Observable that emits the response from the server.
+     */
+    uploadMediaFile(mediaObject) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.post(`${API.fileUpload}`, mediaObject, headers);
+        }
+        return of(null);
+    }
+    /**
+     * Retrieves a file from the server by its media ID.
+     * @param mediaId The ID of the media file to retrieve.
+     * @returns An Observable that emits the file as a Blob.
+     */
+    getFileByMediaId(mediaId, params) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.getBlob(`${API.getMediaFile}?mediaId=${mediaId}`, params, headers);
+        }
+        return of();
+    }
+    /**
+     * Downloads all files from the given URL.
+     * @param endPointName The URL to download files from.
+     * @returns An Observable that emits the downloaded files as a Blob.
+     */
+    downloadAllFiles(endPointName) {
+        return this.apiService.getBlob(endPointName);
+    }
+    /**
+     * Downloads PDF files from the given URL.
+     * @param endPointName The URL to download PDF files from.
+     * @param data The data to send along with the request.
+     * @returns An Observable that emits the downloaded PDF files as a Blob.
+     */
+    downloadPdfFiles(endPointName, data) {
+        const headers = getHeaders();
+        if (headers) {
+            return this.apiService.postBlob(endPointName, data, headers);
+        }
+        return of();
+    }
+    /**
+     * Retrieves an image from the server by its media ID.
+     * @param mediaId The ID of the media file to retrieve.
+     * @returns An Observable that emits the image as a Blob.
+     */
+    getImageByMediaId(mediaId, params) {
+        const headers = getHeaders();
+        if (headers) {
+            const endPointName = `${API.getImage}?mediaId=${mediaId}`;
+            return this.apiService.get(endPointName, params, headers);
+        }
+        return of();
+    }
+    static { this.ɵfac = function MediaUploadHelper_Factory(t) { return new (t || MediaUploadHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MediaUploadHelper, factory: MediaUploadHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MediaUploadHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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