@techextensor/tab-core-utility 2.1.7 → 2.1.9

package/esm2022/lib/tab-core-utility/app/utils/operators.util.mjs

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Converts a relational operator value to a number.
+ * @param dataType The relational operator value as a string.
+ * @returns The relational operator value as a number.
+ */
+export function getRelationalOperatorValueToNumber(dataType) {
+    const operatorsMap = {
+        greaterthan: 1,
+        lessthan: 2,
+        equal: 3,
+        in: 4,
+        notin: 5,
+        isnull: 6,
+        isnotnull: 7,
+        notequal: 8,
+        greaterthanorequal: 9,
+        lessthanorequal: 10,
+        contains: 11,
+        notcontains: 12,
+        startswith: 13,
+        notstartswith: 14,
+        endswith: 15,
+        notendswith: 16,
+        between: 17,
+        notbetween: 18,
+        splitcontains: 19,
+        notsplitcontains: 20,
+    };
+    return operatorsMap[dataType] || 0;
+}
+/**
+ * Converts a relational operator value to a string.
+ * @param dataType The relational operator value as a number.
+ * @returns The relational operator value as a string.
+ */
+export function getRelationalOperatorValueToString(dataType) {
+    const operatorsMap = {
+        1: 'greaterthan',
+        2: 'lessthan',
+        3: 'equal',
+        4: 'in',
+        5: 'notin',
+        6: 'isnull',
+        7: 'isnotnull',
+        8: 'notequal',
+        9: 'greaterthanorequal',
+        10: 'lessthanorequal',
+        11: 'contains',
+        12: 'notcontains',
+        13: 'startswith',
+        14: 'notstartswith',
+        15: 'endswith',
+        16: 'notendswith',
+        17: 'between',
+        18: 'notbetween',
+        19: 'splitcontains',
+        20: 'notsplitcontains',
+    };
+    return operatorsMap[dataType] || '';
+}
+/**
+ * Returns a list of operators for the query builder based on the data type.
+ * @param dataType The data type.
+ * @returns A list of operators.
+ */
+export function getOperatorListForQueryBuilder(dataType) {
+    let operators = [];
+    if (dataType === 'string') {
+        operators = [
+            { value: 'equal', key: 'Equal To' },
+            { value: 'in', key: 'IN' },
+            { value: 'notin', key: 'NOT IN' },
+            { value: 'isnull', key: 'Is NULL' },
+            { value: 'isnotnull', key: 'Is Not NULL' },
+            { value: 'notequal', key: 'Not Equal To' },
+            { value: 'contains', key: 'Contains' },
+            { value: 'notcontains', key: 'Not Contains' },
+            { value: 'startswith', key: 'Starts With' },
+            { value: 'notstartswith', key: 'Not Starts With' },
+            { value: 'endswith', key: 'Ends With' },
+            { value: 'notendswith', key: 'Not Ends With' },
+            { value: 'splitcontains', key: 'SplitContains' },
+            { value: 'notsplitcontains', key: 'Not SplitContains' },
+        ];
+    }
+    else if (dataType === 'number') {
+        operators = [
+            { value: 'greaterthan', key: 'Greater Than' },
+            { value: 'lessthan', key: 'Less Than' },
+            { value: 'equal', key: 'Equal To' },
+            { value: 'isnull', key: 'Is NULL' },
+            { value: 'isnotnull', key: 'Is Not NULL' },
+            { value: 'notequal', key: 'Not Equal To' },
+            { value: 'greaterthanorequal', key: 'Greater Than OR Equal To' },
+            { value: 'lessthanorequal', key: 'Less Than OR Equal To' },
+        ];
+    }
+    else if (dataType === 'Date' || dataType === 'date') {
+        operators = [
+            { value: 'greaterthan', key: 'Greater Than' },
+            { value: 'lessthan', key: 'Less Than' },
+            { value: 'equal', key: 'Equal To' },
+            { value: 'isnull', key: 'Is NULL' },
+            { value: 'isnotnull', key: 'Is Not NULL' },
+            { value: 'notequal', key: 'Not Equal To' },
+            { value: 'greaterthanorequal', key: 'Greater Than OR Equal To' },
+            { value: 'lessthanorequal', key: 'Less Than OR Equal To' },
+            { value: 'contains', key: 'Contains' },
+            { value: 'notcontains', key: 'Not Contains' },
+            { value: 'startswith', key: 'Starts With' },
+            { value: 'notstartswith', key: 'Not Starts With' },
+            { value: 'endswith', key: 'Ends With' },
+            { value: 'notendswith', key: 'Not Ends With' },
+        ];
+    }
+    else if (dataType === 'boolean') {
+        operators = [
+            { value: 'equal', key: 'Equal To' },
+            { value: 'isnull', key: 'Is NULL' },
+            { value: 'isnotnull', key: 'Is Not NULL' },
+            { value: 'notequal', key: 'Not Equal To' },
+            { value: 'contains', key: 'Contains' },
+            { value: 'notcontains', key: 'Not Contains' },
+        ];
+    }
+    return operators;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operators.util.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/utils/operators.util.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/**\r\n * Converts a relational operator value to a number.\r\n * @param dataType The relational operator value as a string.\r\n * @returns The relational operator value as a number.\r\n */\r\nexport function getRelationalOperatorValueToNumber(dataType: string): number {\r\n  const operatorsMap: Record<string, number> = {\r\n    greaterthan: 1,\r\n    lessthan: 2,\r\n    equal: 3,\r\n    in: 4,\r\n    notin: 5,\r\n    isnull: 6,\r\n    isnotnull: 7,\r\n    notequal: 8,\r\n    greaterthanorequal: 9,\r\n    lessthanorequal: 10,\r\n    contains: 11,\r\n    notcontains: 12,\r\n    startswith: 13,\r\n    notstartswith: 14,\r\n    endswith: 15,\r\n    notendswith: 16,\r\n    between: 17,\r\n    notbetween: 18,\r\n    splitcontains: 19,\r\n    notsplitcontains: 20,\r\n  };\r\n  return operatorsMap[dataType] || 0;\r\n}\r\n\r\n/**\r\n * Converts a relational operator value to a string.\r\n * @param dataType The relational operator value as a number.\r\n * @returns The relational operator value as a string.\r\n */\r\nexport function getRelationalOperatorValueToString(dataType: number): string {\r\n  const operatorsMap: Record<number, string> = {\r\n    1: 'greaterthan',\r\n    2: 'lessthan',\r\n    3: 'equal',\r\n    4: 'in',\r\n    5: 'notin',\r\n    6: 'isnull',\r\n    7: 'isnotnull',\r\n    8: 'notequal',\r\n    9: 'greaterthanorequal',\r\n    10: 'lessthanorequal',\r\n    11: 'contains',\r\n    12: 'notcontains',\r\n    13: 'startswith',\r\n    14: 'notstartswith',\r\n    15: 'endswith',\r\n    16: 'notendswith',\r\n    17: 'between',\r\n    18: 'notbetween',\r\n    19: 'splitcontains',\r\n    20: 'notsplitcontains',\r\n  };\r\n  return operatorsMap[dataType] || '';\r\n}\r\n\r\n/**\r\n * Returns a list of operators for the query builder based on the data type.\r\n * @param dataType The data type.\r\n * @returns A list of operators.\r\n */\r\nexport function getOperatorListForQueryBuilder(\r\n  dataType: any\r\n): { value: string; key: string }[] {\r\n  let operators: { value: string; key: string }[] = [];\r\n  if (dataType === 'string') {\r\n    operators = [\r\n      { value: 'equal', key: 'Equal To' },\r\n      { value: 'in', key: 'IN' },\r\n      { value: 'notin', key: 'NOT IN' },\r\n      { value: 'isnull', key: 'Is NULL' },\r\n      { value: 'isnotnull', key: 'Is Not NULL' },\r\n      { value: 'notequal', key: 'Not Equal To' },\r\n      { value: 'contains', key: 'Contains' },\r\n      { value: 'notcontains', key: 'Not Contains' },\r\n      { value: 'startswith', key: 'Starts With' },\r\n      { value: 'notstartswith', key: 'Not Starts With' },\r\n      { value: 'endswith', key: 'Ends With' },\r\n      { value: 'notendswith', key: 'Not Ends With' },\r\n      { value: 'splitcontains', key: 'SplitContains' },\r\n      { value: 'notsplitcontains', key: 'Not SplitContains' },\r\n    ];\r\n  } else if (dataType === 'number') {\r\n    operators = [\r\n      { value: 'greaterthan', key: 'Greater Than' },\r\n      { value: 'lessthan', key: 'Less Than' },\r\n      { value: 'equal', key: 'Equal To' },\r\n      { value: 'isnull', key: 'Is NULL' },\r\n      { value: 'isnotnull', key: 'Is Not NULL' },\r\n      { value: 'notequal', key: 'Not Equal To' },\r\n      { value: 'greaterthanorequal', key: 'Greater Than OR Equal To' },\r\n      { value: 'lessthanorequal', key: 'Less Than OR Equal To' },\r\n    ];\r\n  } else if (dataType === 'Date' || dataType === 'date') {\r\n    operators = [\r\n      { value: 'greaterthan', key: 'Greater Than' },\r\n      { value: 'lessthan', key: 'Less Than' },\r\n      { value: 'equal', key: 'Equal To' },\r\n      { value: 'isnull', key: 'Is NULL' },\r\n      { value: 'isnotnull', key: 'Is Not NULL' },\r\n      { value: 'notequal', key: 'Not Equal To' },\r\n      { value: 'greaterthanorequal', key: 'Greater Than OR Equal To' },\r\n      { value: 'lessthanorequal', key: 'Less Than OR Equal To' },\r\n      { value: 'contains', key: 'Contains' },\r\n      { value: 'notcontains', key: 'Not Contains' },\r\n      { value: 'startswith', key: 'Starts With' },\r\n      { value: 'notstartswith', key: 'Not Starts With' },\r\n      { value: 'endswith', key: 'Ends With' },\r\n      { value: 'notendswith', key: 'Not Ends With' },\r\n    ];\r\n  } else if (dataType === 'boolean') {\r\n    operators = [\r\n      { value: 'equal', key: 'Equal To' },\r\n      { value: 'isnull', key: 'Is NULL' },\r\n      { value: 'isnotnull', key: 'Is Not NULL' },\r\n      { value: 'notequal', key: 'Not Equal To' },\r\n      { value: 'contains', key: 'Contains' },\r\n      { value: 'notcontains', key: 'Not Contains' },\r\n    ];\r\n  }\r\n  return operators;\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/utils/req-res.util.mjs

@@ -0,0 +1,168 @@
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpHeaders } from '@angular/common/http';
+import { Common } from '../constants/common';
+import { getAppObject, getDsqIdfromSelectedAppObjectDSQArray, } from './tab-app.util';
+import { API } from '../constants/api-constants';
+import { getFormBuilderType } from './form-builder.util';
+import { StorageConstants } from '../constants/storage-constants';
+// import { inject } from '@angular/core';
+import { SessionStorageService } from '../../auth/session-storage.service';
+import { API_URL } from '../../core/http-client/api-url.token';
+// const sessionStorageService = inject(SessionStorageService);
+const sessionStorageService = new SessionStorageService();
+/**
+ * Delete a key from the response object
+ *
+ * @param response - The response object
+ * @param key - The key to be deleted
+ * @returns any - The updated response object
+ */
+export function deleteKeyFromResponse(response, key) {
+    delete response[key];
+    return response;
+}
+/**
+ * Remove the primary key from the response object
+ *
+ * @param response - The response object
+ * @param field - The field to be removed as primary key
+ * @returns any - The updated response object
+ */
+export function removePrimaryKey(response, field) {
+    if (field) {
+        deleteKeyFromResponse(response, field);
+    }
+    return response;
+}
+/**
+ * Remove multiple primary keys from the response object
+ *
+ * @param response - The response object
+ * @param fields - The array of fields to be removed as primary keys
+ * @returns any - The updated response object
+ */
+export function removeMultiplePrimaryKey(response, fields) {
+    fields.forEach((element) => {
+        delete response[element.FieldName];
+    });
+    return response;
+}
+/**
+ * Get the HttpHeaders for API requests
+ *
+ * @returns HttpHeaders | null - The HttpHeaders object or null
+ */
+export function getHeaders() {
+    const token = sessionStorageService.getSessionStorage(StorageConstants.token);
+    const staticToken = sessionStorageService.getSessionStorage(StorageConstants.staticToken);
+    if (!token && staticToken) {
+        // Token is empty but staticToken is not
+        return new HttpHeaders({
+            'Content-Type': 'application/json',
+            Authorization: staticToken,
+            ApplicationCode: Common.applicationCode,
+        });
+    }
+    else if (token) {
+        // Token is not empty
+        return new HttpHeaders({
+            'Content-Type': 'application/json',
+            Authorization: token,
+            ApplicationCode: Common.applicationCode,
+        });
+    }
+    // Handle the case when both tokens are empty
+    return null;
+}
+/**
+ * Get the primary key fields from the AppObject
+ *
+ * @param appObject - The AppObject
+ * @returns AppFields[] | null - The array of primary key fields or null
+ */
+export function getPrimaryKeyFields(appObject) {
+    if (appObject.Fields.length) {
+        return appObject.Fields.filter((field) => field.IsPrimaryKey);
+    }
+    return null;
+}
+/**
+ * Get the edit record ID from the response object
+ *
+ * @param response - The response object
+ * @param fieldName - The field name for the edit record ID
+ * @returns any - The edit record ID
+ */
+export function getEditRecordId(response, fieldName) {
+    let recordId = null;
+    if (fieldName) {
+        recordId = response[fieldName] || null;
+    }
+    else {
+        recordId = response.Id || response.ID || null;
+    }
+    return recordId;
+}
+/**
+ * Generate the fields schema based on the AppFields
+ *
+ * @param fields - The AppFields object
+ * @returns any - The generated fields schema
+ */
+export function generateFieldsSchema(fields) {
+    let schema = {};
+    if (fields.hasOwnProperty('LookUpDetails')) {
+        const selectedAppObject = getAppObject(fields.LookUpDetails.LookupObject);
+        const dsqID = getDsqIdfromSelectedAppObjectDSQArray(selectedAppObject?.DataSourceQueries, fields.LookUpDetails.LookupObject, 'List');
+        schema = {
+            label: fields.DisplayName,
+            type: 'select',
+            key: fields.SystemDBFieldName,
+            input: true,
+            dataSrc: 'url',
+            valueProperty: fields.LookUpDetails.LookupField,
+            template: `<span>{{ item.${fields.LookUpDetails.DisplayField} }}</span>`,
+            selectValues: 'Result',
+            data: {
+                url: `${API_URL}${API.getListFromDsq}${dsqID}`, // API.getListFromDsq + dsqID,
+                headers: [
+                    {
+                        "key": "Applicationcode",
+                        "value": sessionStorageService.getSessionStorage(StorageConstants.applicationCode)
+                    },
+                    {
+                        "key": "Authorization",
+                        "value": sessionStorageService.getSessionStorage(StorageConstants.token)
+                    }
+                ],
+            },
+        };
+    }
+    else {
+        schema = {
+            label: fields.DisplayName,
+            type: getFormBuilderType(fields.FieldType.DataType),
+            key: fields.SystemDBFieldName,
+            input: true,
+        };
+    }
+    return schema;
+}
+/**
+ * Get the HttpHeaders for form data requests
+ *
+ * @returns HttpHeaders | null - The HttpHeaders object or null
+ */
+export function getFormDataHeaders() {
+    const isToken = sessionStorageService.getSessionStorage(StorageConstants.token);
+    if (isToken) {
+        return new HttpHeaders({
+            Accept: '*/*',
+            Authorization: isToken,
+            ApplicationCode: Common.applicationCode,
+        });
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"req-res.util.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/utils/req-res.util.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EACL,YAAY,EACZ,qCAAqC,GACtC,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,GAAG,EAAE,MAAM,4BAA4B,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,0CAA0C;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAE/D,+DAA+D;AAC/D,MAAM,qBAAqB,GAAG,IAAI,qBAAqB,EAAE,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAa,EAAE,GAAW;IAC9D,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;IACrB,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAa,EAAE,KAAa;IAC3D,IAAI,KAAK,EAAE,CAAC;QACV,qBAAqB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAa,EAAE,MAAW;IACjE,MAAM,CAAC,OAAO,CAAC,CAAC,OAAY,EAAE,EAAE;QAC9B,OAAO,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU;IACxB,MAAM,KAAK,GAAG,qBAAqB,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC9E,MAAM,WAAW,GAAG,qBAAqB,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAE1F,IAAI,CAAC,KAAK,IAAI,WAAW,EAAE,CAAC;QACxB,wCAAwC;QACxC,OAAO,IAAI,WAAW,CAAC;YACnB,cAAc,EAAE,kBAAkB;YAClC,aAAa,EAAE,WAAW;YAC1B,eAAe,EAAE,MAAM,CAAC,eAAe;SAC1C,CAAC,CAAC;IACP,CAAC;SAAM,IAAI,KAAK,EAAE,CAAC;QACf,qBAAqB;QACrB,OAAO,IAAI,WAAW,CAAC;YACnB,cAAc,EAAE,kBAAkB;YAClC,aAAa,EAAE,KAAK;YACpB,eAAe,EAAE,MAAM,CAAC,eAAe;SAC1C,CAAC,CAAC;IACP,CAAC;IACD,6CAA6C;IAC7C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AAEH,MAAM,UAAU,mBAAmB,CAAC,SAAoB;IACtD,IAAI,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,QAAa,EAAE,SAAc;IAC3D,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,IAAI,SAAS,EAAE,CAAC;QACd,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;IACzC,CAAC;SAAM,CAAC;QACN,QAAQ,GAAG,QAAQ,CAAC,EAAE,IAAI,QAAQ,CAAC,EAAE,IAAI,IAAI,CAAC;IAChD,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAiB;IACpD,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,MAAM,CAAC,cAAc,CAAC,eAAe,CAAC,EAAE,CAAC;QAC3C,MAAM,iBAAiB,GAAc,YAAY,CAC/C,MAAM,CAAC,aAAa,CAAC,YAAY,CAClC,CAAC;QACF,MAAM,KAAK,GAAG,qCAAqC,CACjD,iBAAiB,EAAE,iBAAiB,EACpC,MAAM,CAAC,aAAa,CAAC,YAAY,EACjC,MAAM,CACP,CAAC;QACF,MAAM,GAAG;YACP,KAAK,EAAE,MAAM,CAAC,WAAW;YACzB,IAAI,EAAE,QAAQ;YACd,GAAG,EAAE,MAAM,CAAC,iBAAiB;YAC7B,KAAK,EAAE,IAAI;YACX,OAAO,EAAE,KAAK;YACd,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,WAAW;YAC/C,QAAQ,EAAE,iBAAiB,MAAM,CAAC,aAAa,CAAC,YAAY,YAAY;YACxE,YAAY,EAAE,QAAQ;YACtB,IAAI,EAAE;gBACJ,GAAG,EAAE,GAAG,OAAO,GAAG,GAAG,CAAC,cAAc,GAAG,KAAK,EAAE,EAAC,8BAA8B;gBAC7E,OAAO,EAAE;oBACP;wBACE,KAAK,EAAE,iBAAiB;wBACxB,OAAO,EAAE,qBAAqB,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,eAAe,CAAC;qBACnF;oBACD;wBACE,KAAK,EAAE,eAAe;wBACtB,OAAO,EAAE,qBAAqB,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,KAAK,CAAC;qBACzE;iBACF;aACF;SAEF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,MAAM,GAAG;YACP,KAAK,EAAE,MAAM,CAAC,WAAW;YACzB,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC;YACnD,GAAG,EAAE,MAAM,CAAC,iBAAiB;YAC7B,KAAK,EAAE,IAAI;SACZ,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,OAAO,GAAG,qBAAqB,CAAC,iBAAiB,CACrD,gBAAgB,CAAC,KAAK,CACvB,CAAC;IACF,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,IAAI,WAAW,CAAC;YACrB,MAAM,EAAE,KAAK;YACb,aAAa,EAAE,OAAO;YACtB,eAAe,EAAE,MAAM,CAAC,eAAe;SACxC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/* eslint-disable no-prototype-builtins */\r\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { HttpHeaders } from '@angular/common/http';\r\nimport { Common } from '../constants/common';\r\nimport { AppObject } from '../models/app-object.class';\r\nimport {\r\n  getAppObject,\r\n  getDsqIdfromSelectedAppObjectDSQArray,\r\n} from './tab-app.util';\r\nimport { AppFields } from '../models/data-source-queries.class';\r\nimport { API } from '../constants/api-constants';\r\nimport { getFormBuilderType } from './form-builder.util';\r\nimport { StorageConstants } from '../constants/storage-constants';\r\n// import { inject } from '@angular/core';\r\nimport { SessionStorageService } from '../../auth/session-storage.service';\r\nimport { API_URL } from '../../core/http-client/api-url.token';\r\n\r\n// const sessionStorageService = inject(SessionStorageService);\r\nconst sessionStorageService = new SessionStorageService();\r\n\r\n/**\r\n * Delete a key from the response object\r\n *\r\n * @param response - The response object\r\n * @param key - The key to be deleted\r\n * @returns any - The updated response object\r\n */\r\nexport function deleteKeyFromResponse(response: any, key: string) {\r\n  delete response[key];\r\n  return response;\r\n}\r\n\r\n/**\r\n * Remove the primary key from the response object\r\n *\r\n * @param response - The response object\r\n * @param field - The field to be removed as primary key\r\n * @returns any - The updated response object\r\n */\r\nexport function removePrimaryKey(response: any, field: string) {\r\n  if (field) {\r\n    deleteKeyFromResponse(response, field);\r\n  }\r\n  return response;\r\n}\r\n\r\n/**\r\n * Remove multiple primary keys from the response object\r\n *\r\n * @param response - The response object\r\n * @param fields - The array of fields to be removed as primary keys\r\n * @returns any - The updated response object\r\n */\r\nexport function removeMultiplePrimaryKey(response: any, fields: any) {\r\n  fields.forEach((element: any) => {\r\n    delete response[element.FieldName];\r\n  });\r\n  return response;\r\n}\r\n\r\n/**\r\n * Get the HttpHeaders for API requests\r\n *\r\n * @returns HttpHeaders | null - The HttpHeaders object or null\r\n */\r\nexport function getHeaders() {\r\n  const token = sessionStorageService.getSessionStorage(StorageConstants.token);\r\n  const staticToken = sessionStorageService.getSessionStorage(StorageConstants.staticToken);\r\n  \r\n  if (!token && staticToken) {\r\n      // Token is empty but staticToken is not\r\n      return new HttpHeaders({\r\n          'Content-Type': 'application/json',\r\n          Authorization: staticToken,\r\n          ApplicationCode: Common.applicationCode,\r\n      });\r\n  } else if (token) {\r\n      // Token is not empty\r\n      return new HttpHeaders({\r\n          'Content-Type': 'application/json',\r\n          Authorization: token,\r\n          ApplicationCode: Common.applicationCode,\r\n      });\r\n  }\r\n  // Handle the case when both tokens are empty\r\n  return null;\r\n}\r\n\r\n/**\r\n * Get the primary key fields from the AppObject\r\n *\r\n * @param appObject - The AppObject\r\n * @returns AppFields[] | null - The array of primary key fields or null\r\n */\r\n\r\nexport function getPrimaryKeyFields(appObject: AppObject) {\r\n  if (appObject.Fields.length) {\r\n    return appObject.Fields.filter((field) => field.IsPrimaryKey);\r\n  }\r\n  return null;\r\n}\r\n\r\n/**\r\n * Get the edit record ID from the response object\r\n *\r\n * @param response - The response object\r\n * @param fieldName - The field name for the edit record ID\r\n * @returns any - The edit record ID\r\n */\r\nexport function getEditRecordId(response: any, fieldName: any) {\r\n  let recordId = null;\r\n  if (fieldName) {\r\n    recordId = response[fieldName] || null;\r\n  } else {\r\n    recordId = response.Id || response.ID || null;\r\n  }\r\n  return recordId;\r\n}\r\n\r\n/**\r\n * Generate the fields schema based on the AppFields\r\n *\r\n * @param fields - The AppFields object\r\n * @returns any - The generated fields schema\r\n */\r\nexport function generateFieldsSchema(fields: AppFields) {\r\n  let schema = {};\r\n  if (fields.hasOwnProperty('LookUpDetails')) {\r\n    const selectedAppObject: AppObject = getAppObject(\r\n      fields.LookUpDetails.LookupObject\r\n    );\r\n    const dsqID = getDsqIdfromSelectedAppObjectDSQArray(\r\n      selectedAppObject?.DataSourceQueries,\r\n      fields.LookUpDetails.LookupObject,\r\n      'List'\r\n    );\r\n    schema = {\r\n      label: fields.DisplayName,\r\n      type: 'select',\r\n      key: fields.SystemDBFieldName,\r\n      input: true,\r\n      dataSrc: 'url',\r\n      valueProperty: fields.LookUpDetails.LookupField,\r\n      template: `<span>{{ item.${fields.LookUpDetails.DisplayField} }}</span>`,\r\n      selectValues: 'Result',\r\n      data: {\r\n        url: `${API_URL}${API.getListFromDsq}${dsqID}`,// API.getListFromDsq + dsqID,\r\n        headers: [\r\n          {\r\n            \"key\": \"Applicationcode\",\r\n            \"value\": sessionStorageService.getSessionStorage(StorageConstants.applicationCode)\r\n          },\r\n          {\r\n            \"key\": \"Authorization\",\r\n            \"value\": sessionStorageService.getSessionStorage(StorageConstants.token)\r\n          }\r\n        ],\r\n      },\r\n      \r\n    };\r\n  } else {\r\n    schema = {\r\n      label: fields.DisplayName,\r\n      type: getFormBuilderType(fields.FieldType.DataType),\r\n      key: fields.SystemDBFieldName,\r\n      input: true,\r\n    };\r\n  }\r\n  return schema;\r\n}\r\n\r\n/**\r\n * Get the HttpHeaders for form data requests\r\n *\r\n * @returns HttpHeaders | null - The HttpHeaders object or null\r\n */\r\nexport function getFormDataHeaders() {\r\n  const isToken = sessionStorageService.getSessionStorage(\r\n    StorageConstants.token\r\n  );\r\n  if (isToken) {\r\n    return new HttpHeaders({\r\n      Accept: '*/*',\r\n      Authorization: isToken,\r\n      ApplicationCode: Common.applicationCode,\r\n    });\r\n  }\r\n  return null;\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/utils/tab-app.util.mjs

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Common } from '../constants/common';
+import { deleteKeyFromResponse } from './req-res.util';
+/** Get the DataSourceQuery ID from the selected AppObject's DataSourceQuery array
+ * @param dsqList - The list of DataSourceQueries
+ * @param table - The table name
+ * @param like - The like string
+ * @returns string - The ID of the DataSourceQuery
+ */
+export function getDsqIdfromSelectedAppObjectDSQArray(dsqList, table, like) {
+    if (dsqList) {
+        const matchName = like + '_' + table;
+        const result = dsqList.find((d) => d.QueryName === matchName);
+        return result?.ID;
+    }
+}
+/** Get the AppObject based on the provided ID
+ * @param id - The ID of the AppObject
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObject(id) {
+    const tabData = Common.tabJson;
+    return (tabData?.AppObjects.find((t) => t.ID === id?.toLowerCase()) || null);
+}
+/**
+ * Get the AppObject from the DataSourceQuery ID
+ * @param dsqId - The DataSourceQuery ID
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObjectFromDataSourceQueryID(dsqId) {
+    const tabData = Common.tabJson;
+    if (!dsqId || !tabData) {
+        return null;
+    }
+    for (const appObject of tabData.AppObjects) {
+        const dsq = appObject.DataSourceQueries.find((l) => l.ID === dsqId?.toLowerCase());
+        if (dsq) {
+            return appObject;
+        }
+    }
+    return null;
+}
+/**
+ * Get the DataSourceQuery ID from the QueryName and table
+ * @param table - The table name
+ * @param dsq - The DataSourceQuery name
+ * @returns any - The found DataSourceQuery
+ */
+export function getDsqIDFromQueryName(table, dsq) {
+    const appObjectList = getAppObjectFromSystemDBTableName(table);
+    return appObjectList?.DataSourceQueries.find((d) => d.QueryName === dsq);
+}
+/**
+ * Get the Data from the DataSourceQuery ID
+ *
+ * @param dsqId - The DataSourceQuery ID
+ * @returns any - The found Data
+ */
+export function getDataFromDataSourceQueryID(dsqId) {
+    const tabData = Common.tabJson;
+    if (!tabData) {
+        return null;
+    }
+    for (const appObject of tabData.AppObjects) {
+        const DSQ = appObject.DataSourceQueries.find((l) => l.ID === dsqId?.toLowerCase());
+        if (DSQ) {
+            return DSQ;
+        }
+    }
+    return null;
+}
+/**
+ * Synchronize AppObject fields with the response
+ *
+ * @param response - The response object
+ * @param appObject - The AppObject
+ * @returns any - The synchronized response object
+ */
+export function syncAppObjectFields(response, appObject) {
+    for (const key in response) {
+        const foundObj = appObject.Fields.find((f) => f.FieldName === key);
+        const chilData = appObject.ChildRelationShips?.map((x) => x.childDetails.LookupObject);
+        if (!foundObj && !(chilData && chilData.some((x) => x.includes(key)))) {
+            deleteKeyFromResponse(response, key);
+        }
+    }
+    return response;
+}
+/**
+ * Get the AppObject based on the SystemDBTableName
+ *
+ * @param tableName - The SystemDBTableName
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObjectFromSystemDBTableName(tableName) {
+    const tabData = Common.tabJson;
+    return (tabData?.AppObjects.find((t) => t.SystemDBTableName === tableName) || null);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-app.util.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/utils/tab-app.util.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Common } from '../constants/common';\r\nimport { AppObject } from '../models/app-object.class';\r\nimport { deleteKeyFromResponse } from './req-res.util';\r\n\r\n/** Get the DataSourceQuery ID from the selected AppObject's DataSourceQuery array\r\n * @param dsqList - The list of DataSourceQueries\r\n * @param table - The table name\r\n * @param like - The like string\r\n * @returns string - The ID of the DataSourceQuery\r\n */\r\n\r\nexport function getDsqIdfromSelectedAppObjectDSQArray(\r\n  dsqList: any,\r\n  table: string,\r\n  like: string\r\n) {\r\n  if (dsqList) {\r\n    const matchName = like + '_' + table;\r\n    const result = dsqList.find((d: any) => d.QueryName === matchName);\r\n    return result?.ID;\r\n  }\r\n}\r\n\r\n/** Get the AppObject based on the provided ID\r\n * @param id - The ID of the AppObject\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\n\r\nexport function getAppObject(id: string) {\r\n  const tabData: any | null = Common.tabJson;\r\n  return (\r\n    tabData?.AppObjects.find((t: any) => t.ID === id?.toLowerCase()) || null\r\n  );\r\n}\r\n\r\n/**\r\n * Get the AppObject from the DataSourceQuery ID\r\n * @param dsqId - The DataSourceQuery ID\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\n\r\nexport function getAppObjectFromDataSourceQueryID(dsqId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  if (!dsqId || !tabData) {\r\n    return null;\r\n  }\r\n\r\n  for (const appObject of tabData.AppObjects) {\r\n    const dsq = appObject.DataSourceQueries.find(\r\n      (l: any) => l.ID === dsqId?.toLowerCase()\r\n    );\r\n    if (dsq) {\r\n      return appObject;\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Get the DataSourceQuery ID from the QueryName and table\r\n * @param table - The table name\r\n * @param dsq - The DataSourceQuery name\r\n * @returns any - The found DataSourceQuery\r\n */\r\nexport function getDsqIDFromQueryName(table: string, dsq: string) {\r\n  const appObjectList = getAppObjectFromSystemDBTableName(table);\r\n  return appObjectList?.DataSourceQueries.find((d: any) => d.QueryName === dsq);\r\n}\r\n\r\n/**\r\n * Get the Data from the DataSourceQuery ID\r\n *\r\n * @param dsqId - The DataSourceQuery ID\r\n * @returns any - The found Data\r\n */\r\n\r\nexport function getDataFromDataSourceQueryID(dsqId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  if (!tabData) {\r\n    return null;\r\n  }\r\n\r\n  for (const appObject of tabData.AppObjects) {\r\n    const DSQ = appObject.DataSourceQueries.find(\r\n      (l: any) => l.ID === dsqId?.toLowerCase()\r\n    );\r\n    if (DSQ) {\r\n      return DSQ;\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Synchronize AppObject fields with the response\r\n *\r\n * @param response - The response object\r\n * @param appObject - The AppObject\r\n * @returns any - The synchronized response object\r\n */\r\nexport function syncAppObjectFields(response: any, appObject: AppObject) {\r\n  for (const key in response) {\r\n    const foundObj = appObject.Fields.find((f: any) => f.FieldName === key);\r\n    const chilData = appObject.ChildRelationShips?.map(\r\n      (x) => x.childDetails.LookupObject\r\n    );\r\n    if (!foundObj && !(chilData && chilData.some((x) => x.includes(key)))) {\r\n      deleteKeyFromResponse(response, key);\r\n    }\r\n  }\r\n  return response;\r\n}\r\n\r\n/**\r\n * Get the AppObject based on the SystemDBTableName\r\n *\r\n * @param tableName - The SystemDBTableName\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\nexport function getAppObjectFromSystemDBTableName(tableName: string) {\r\n  const tabData: any = Common.tabJson;\r\n  return (\r\n    tabData?.AppObjects.find(\r\n      (t: { SystemDBTableName: string }) => t.SystemDBTableName === tableName\r\n    ) || null\r\n  );\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/auth/auth.service.mjs

@@ -0,0 +1,74 @@
+import { Injectable, inject } from '@angular/core';
+import { ApiService } from '../core/http-client/api.service';
+import { LocalStorageService } from './local-storage.service';
+import * as i0 from "@angular/core";
+export class AuthService {
+    constructor() {
+        /**
+         * Injecting required services
+         */
+        this.apiService = inject(ApiService);
+        this.localStorageService = inject(LocalStorageService);
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Public methods
+    // -----------------------------------------------------------------------------------------------------
+    /**
+     * Fetch user details from the database
+     *
+     * @param endPointName - The End Point Name to fetch user details
+     * @returns Observable<UserResponse> - An observable of UserResponse
+     */
+    user(endPointName) {
+        return this.apiService.get(endPointName);
+    }
+    /**
+     * Sign in with provided credentials
+     *
+     * @param endPointName - The End Point Name to sign in
+     * @param credentials - The login credentials
+     * @returns Observable<UserResponse> - An observable of UserResponse
+     */
+    signIn(endPointName, credentials) {
+        return this.apiService.post(endPointName, credentials);
+    }
+    /**
+     * Register a new user
+     *
+     * @param endPointName - The End Point Name to register a new user
+     * @param credentials - The new user's credentials
+     * @returns Observable<UserResponse> - An observable of UserResponse
+     */
+    register(endPointName, credentials) {
+        return this.apiService.post(endPointName, credentials);
+    }
+    /**
+     * Forgot password
+     * @param endPointName - The End Point Name of API
+     * @param email - The email of user
+     */
+    forgotPassword(endPointName, email) {
+        return this.apiService.post(endPointName, email);
+    }
+    /**
+     * Reset password
+     * @param endPointName - The End Point Name of API
+     * @param password - The password of user
+     */
+    resetPassword(endPointName, password) {
+        return this.apiService.post(endPointName, password);
+    }
+    /**
+     * Logout current session
+     */
+    logout(key) {
+        this.localStorageService.removeLocalStorage(key);
+    }
+    static { this.ɵfac = function AuthService_Factory(t) { return new (t || AuthService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthService, factory: AuthService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/auth/idb-storage.service.mjs

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { openDB } from 'idb';
+import * as i0 from "@angular/core";
+export class IdbService {
+    constructor() {
+        this.dbName = 'TabDatabase';
+        this.dbVersion = 1;
+        this.dbPromise = openDB(this.dbName, this.dbVersion, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains('myObjectStore')) {
+                    db.createObjectStore('myObjectStore', { keyPath: 'key' });
+                }
+            },
+        });
+    }
+    async setItem(key, data) {
+        try {
+            if (data) {
+                await this.setItemIndexedDb(key, data);
+            }
+        }
+        catch (error) {
+            throw new Error('Error storing data: ' + error);
+        }
+    }
+    async setItemIndexedDb(key, data) {
+        const db = await this.dbPromise;
+        const tx = db.transaction('myObjectStore', 'readwrite');
+        const store = tx.objectStore('myObjectStore');
+        await store.put({ key, data });
+        await tx.done;
+    }
+    async getItem(key) {
+        try {
+            const result = await this.getItemIndexedDb(key);
+            return result?.data;
+        }
+        catch (error) {
+            throw new Error('Error retrieving data: ' + error);
+        }
+    }
+    async getItemIndexedDb(key) {
+        const db = await this.dbPromise;
+        const tx = db.transaction('myObjectStore', 'readonly');
+        const store = tx.objectStore('myObjectStore');
+        const result = await store.get(key);
+        await tx.done;
+        return result;
+    }
+    async clearIndexedDB() {
+        try {
+            const db = await this.dbPromise;
+            const tx = db.transaction('myObjectStore', 'readwrite');
+            const store = tx.objectStore('myObjectStore');
+            await store.clear();
+            await tx.done;
+        }
+        catch (error) {
+            throw new Error('Error clearing IndexedDB: ' + error);
+        }
+    }
+    static { this.ɵfac = function IdbService_Factory(t) { return new (t || IdbService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: IdbService, factory: IdbService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IdbService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,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