@techextensor/tab-core-utility 2.0.0 → 2.0.1

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,146 @@
+/* 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';
+// 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 isToken = sessionStorageService.getSessionStorage(StorageConstants.token);
+    if (isToken) {
+        return new HttpHeaders({
+            'Content-Type': 'application/json',
+            Authorization: isToken,
+            ApplicationCode: Common.applicationCode,
+        });
+    }
+    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.getListFromDsq + dsqID,
+            },
+        };
+    }
+    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":"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","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\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 isToken = sessionStorageService.getSessionStorage(\r\n    StorageConstants.token\r\n  );\r\n  if (isToken) {\r\n    return new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      Authorization: isToken,\r\n      ApplicationCode: Common.applicationCode,\r\n    });\r\n  }\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.getListFromDsq + dsqID,\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

@@ -16,47 +16,47 @@ export class AuthService {
     /**
      * Fetch user details from the database
      *
-     * @param url - The URL to fetch user details
+     * @param endPointName - The End Point Name to fetch user details
      * @returns Observable<UserResponse> - An observable of UserResponse
      */
-    user(url) {
-        return this.apiService.get(url);
+    user(endPointName) {
+        return this.apiService.get(endPointName);
     }
     /**
      * Sign in with provided credentials
      *
-     * @param url - The URL to sign in
+     * @param endPointName - The End Point Name to sign in
      * @param credentials - The login credentials
      * @returns Observable<UserResponse> - An observable of UserResponse
      */
-    signIn(url, credentials) {
-        return this.apiService.post(url, credentials);
+    signIn(endPointName, credentials) {
+        return this.apiService.post(endPointName, credentials);
     }
     /**
      * Register a new user
      *
-     * @param url - The URL to 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(url, credentials) {
-        return this.apiService.post(url, credentials);
+    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(url, email) {
-        return this.apiService.post(url, email);
+    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(url, password) {
-        return this.apiService.post(url, password);
+    resetPassword(endPointName, password) {
+        return this.apiService.post(endPointName, password);
     }
     /**
      * Logout current session
@@ -71,4 +71,4 @@ export class AuthService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorageService {
+    constructor() {
+        // -----------------------------------------------------------------------------------------------------
+        // @ Public methods
+        // -----------------------------------------------------------------------------------------------------
+        /**
+         * Set data in session storage
+         * @param key - Key to store the data
+         * @param data - Data to be stored
+         */
+        this.setSessionStorage = (key, data) => {
+            sessionStorage.setItem(key, JSON.stringify(data));
+        };
+        /**
+         * Get data from session storage
+         * @param key - Key to retrieve the data
+         * @returns The data stored in session storage
+         */
+        this.getSessionStorage = (key) => {
+            const data = sessionStorage.getItem(key);
+            return data ? JSON.parse(data) : null;
+        };
+        /**
+         * Remove data from session storage
+         * @param key - Key of the data to be removed
+         */
+        this.removeSessionStorage = (key) => {
+            sessionStorage.removeItem(key);
+        };
+    }
+    static { this.ɵfac = function SessionStorageService_Factory(t) { return new (t || SessionStorageService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SessionStorageService, factory: SessionStorageService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SessionStorageService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/core/http-client/api-url.token.mjs

@@ -1,3 +1,4 @@
 import { InjectionToken } from '@angular/core';
 export const API_URL = new InjectionToken('API_URL');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXVybC50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2NvcmUvaHR0cC1jbGllbnQvYXBpLXVybC50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLGNBQWMsQ0FBUyxTQUFTLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBBUElfVVJMID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ0FQSV9VUkwnKTtcbiJdfQ==
+export const Workflow_URL = new InjectionToken('Workflow_URL');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXVybC50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2NvcmUvaHR0cC1jbGllbnQvYXBpLXVybC50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLGNBQWMsQ0FBUyxTQUFTLENBQUMsQ0FBQztBQUM3RCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQVMsY0FBYyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgQVBJX1VSTCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmc+KCdBUElfVVJMJyk7XG5leHBvcnQgY29uc3QgV29ya2Zsb3dfVVJMID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ1dvcmtmbG93X1VSTCcpO1xuIl19