@techextensor/tab-core-utility 2.1.5 → 2.1.7

package/src/lib/tab-core-utility/app/utils/filter.util.ts

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Returns the filter value type as a string.
+ * @param type The filter value type.
+ * @returns The filter value type as a string.
+ */
+export function getFilterValueTypeInString(type: number): string {
+  switch (type) {
+    case 1:
+      return 'Literal';
+    case 2:
+      return 'Parameter';
+    case 3:
+      return 'Property';
+    case 4:
+      return 'Global';
+    default:
+      return '';
+  }
+}
+
+/**
+ * Returns the conjunction clause name based on the type.
+ * @param type The conjunction clause type.
+ * @returns The conjunction clause name.
+ */
+export function getConjuctionClauseName(type: number): string {
+  return type === 1 ? 'and' : 'or';
+}
+
+/**
+ * Returns the conjunction clause value based on the type.
+ * @param type The conjunction clause name.
+ * @returns The conjunction clause value.
+ */
+export function getConjuctionClause(type: string): number {
+  return type === 'and' ? 1 : 2;
+}
+
+/**
+ * Returns the filter type based on the element.
+ * @param element The filter element.
+ * @returns The filter type.
+ */
+export function getFilterType(element: any): string {
+  switch (element.ValueType) {
+    case 1:
+      return element.Value;
+    case 2:
+      return '@' + element.Value;
+    case 3:
+      return '((' + element.Value + '))';
+    case 4:
+      return '[[' + element.Value + ']]';
+    default:
+      return '';
+  }
+}
+
+/**
+ * Returns the filter value type as an integer.
+ * @param type The filter value type.
+ * @returns The filter value type as an integer.
+ */
+export function getFilterValueTypeInInt(type: string): string {
+  switch (type) {
+    case 'Literal':
+      return '1';
+    case 'Parameter':
+      return '2';
+    case 'Property':
+      return '3';
+    case 'Global':
+      return '4';
+    default:
+      return '0';
+  }
+}

package/src/lib/tab-core-utility/app/utils/form-builder.util.ts

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Returns the form builder type based on the data type.
+ * @param dataType The data type.
+ * @returns The form builder type.
+ */
+export function getFormBuilderType(dataType: number): string {
+  if ([1, 7, 13].includes(dataType)) return 'textfield';
+  else if ([2, 3, 4].includes(dataType)) return 'number';
+  else if ([5, 6].includes(dataType)) return 'datetime';
+  else return 'textfield';
+}
+
+/**
+ * Returns the field type based on the data type and whether it's a lookup.
+ * @param dataType The data type.
+ * @param isLookup Indicates if it's a lookup field.
+ * @returns The field type.
+ */
+export function getFieldsType(dataType: number, isLookup: any): string {
+  if (isLookup && dataType !== 6) return 'string';
+  if ([1, 2, 16].includes(dataType)) return 'number';
+  else if (dataType === 3) return 'boolean';
+  else if (
+    [4, ...Array.from({ length: 9 }, (_, i) => i + 7)].includes(dataType)
+  )
+    return 'string';
+  else if (dataType === 5) return 'Date';
+  else if (dataType === 6) return 'date';
+  else return 'string';
+}

package/src/lib/tab-core-utility/app/utils/json.util.ts

@@ -0,0 +1,137 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Validates if a string is a valid JSON.
+ * @param str The string to validate.
+ * @returns True if the string is a valid JSON, false otherwise.
+ */
+export function validateJSON(str: string): boolean {
+  try {
+    const json = JSON.parse(str);
+    return Object.prototype.toString.call(json).slice(8, -1) === 'Object';
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Creates dynamic data based on the input object
+ * @param obj The input object to create dynamic data from
+ * @returns The formatted array
+ */
+export function createDynamicData(obj: any) {
+  return formatArray(obj);
+}
+
+/**
+ * Formats the input object into a new array with AppFieldID and Value pairs
+ * @param input The input object to be formatted
+ * @returns The formatted array with AppFieldID and Value pairs
+ */
+function formatArray(input: any) {
+  if (input !== null) {
+    const newObj = Object.keys(input).map((key) => {
+      let Value: any = '';
+      if (Array.isArray(input[key])) {
+        if (key === 'Child_Relationship') {
+          Value = handleChildRelationship(input[key]);
+        } else {
+          Value = handleObject(input[key]);
+        }
+      } else if (typeof input[key] === 'object') {
+        Value = handleObject(input[key]);
+      } else {
+        Value = input[key];
+      }
+      return { AppFieldID: key, Value };
+    });
+    return newObj;
+  }
+  return null;
+}
+
+/**
+ * Handles the Child_Relationship key in the input object
+ * @param child The value of the Child_Relationship key
+ * @returns The JSON stringified value if not null, empty, or 'null'; otherwise null
+ */
+function handleChildRelationship(child: any) {
+  if (child !== null && child !== '' && child !== 'null') {
+    return JSON.stringify(child);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Handles object keys in the input object based on specific cases
+ * @param obj The object to be handled
+ * @returns The JSON stringified value based on specific cases or recursively formats the object
+ */
+function handleObject(obj: any) {
+  if (obj === null) {
+    return null;
+  }
+  switch (Object.keys(obj)[0]) {
+    case 'Container':
+    case 'Setting_Value':
+    case 'Child_Relationship':
+    case 'ScreenConfiguration':
+    case 'AppObjectConfiguration':
+    case 'SchemaConfig':
+    case 'Criteria':
+    case 'ApplyCriteria':
+    case 'SLASetting':
+      return JSON.stringify(obj);
+    default:
+      return formatArray(obj);
+  }
+}
+
+/**
+ * Removes blank values from the input object
+ * @param dataObj The input object to remove blank values from
+ */
+export function removeBlankValue(dataObj: any) {
+  Object.keys(dataObj).forEach((key) => {
+    if (Array.isArray(dataObj[key])) {
+      dataObj[key].forEach((item: { Value: any }, i: any) => {
+        if (isValueBlank(item.Value)) {
+          dataObj[key].splice(i, 1);
+        } else {
+          removeBlankValue(item);
+        }
+      });
+      if (dataObj[key].length === 0) {
+        delete dataObj[key];
+      }
+    } else if (dataObj[key] && typeof dataObj[key] === 'object') {
+      removeBlankValue(dataObj[key]);
+      if (Object.keys(dataObj[key]).length === 0) {
+        delete dataObj[key];
+      }
+    } else if (key === 'Value' && isValueBlank(dataObj[key])) {
+      delete dataObj[key];
+    }
+  });
+}
+
+/**
+ * Removes blank array keys from the input object
+ * @param dataObj The input object to remove blank array keys from
+ */
+export function removeBlankArrayKeys(dataObj: any) {
+  dataObj.forEach((element: any, i: any) => {
+    if (element && element.hasOwnProperty('Value')) {
+      if (typeof element.Value === 'object' && element.Value.length == 0) {
+        dataObj.splice(i, 1);
+      }
+    }
+  });
+}
+
+function isValueBlank(value: any): boolean {
+  return value === null || value === '';
+}

package/src/lib/tab-core-utility/app/utils/operators.util.ts

@@ -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: string): number {
+  const operatorsMap: Record<string, number> = {
+    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: number): string {
+  const operatorsMap: Record<number, string> = {
+    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: any
+): { value: string; key: string }[] {
+  let operators: { value: string; key: string }[] = [];
+  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;
+}

package/src/lib/tab-core-utility/app/utils/req-res.util.ts

@@ -0,0 +1,189 @@
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpHeaders } from '@angular/common/http';
+import { Common } from '../constants/common';
+import { AppObject } from '../models/app-object.class';
+import {
+  getAppObject,
+  getDsqIdfromSelectedAppObjectDSQArray,
+} from './tab-app.util';
+import { AppFields } from '../models/data-source-queries.class';
+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: any, key: string) {
+  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: any, field: string) {
+  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: any, fields: any) {
+  fields.forEach((element: any) => {
+    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: 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: any, fieldName: any) {
+  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: AppFields) {
+  let schema = {};
+  if (fields.hasOwnProperty('LookUpDetails')) {
+    const selectedAppObject: AppObject = 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;
+}

package/src/lib/tab-core-utility/app/utils/tab-app.util.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { Common } from '../constants/common';
+import { AppObject } from '../models/app-object.class';
+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: any,
+  table: string,
+  like: string
+) {
+  if (dsqList) {
+    const matchName = like + '_' + table;
+    const result = dsqList.find((d: any) => 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: string) {
+  const tabData: any | null = Common.tabJson;
+  return (
+    tabData?.AppObjects.find((t: any) => 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: string) {
+  const tabData: any = Common.tabJson;
+  if (!dsqId || !tabData) {
+    return null;
+  }
+
+  for (const appObject of tabData.AppObjects) {
+    const dsq = appObject.DataSourceQueries.find(
+      (l: any) => 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: string, dsq: string) {
+  const appObjectList = getAppObjectFromSystemDBTableName(table);
+  return appObjectList?.DataSourceQueries.find((d: any) => d.QueryName === dsq);
+}
+
+/**
+ * Get the Data from the DataSourceQuery ID
+ *
+ * @param dsqId - The DataSourceQuery ID
+ * @returns any - The found Data
+ */
+
+export function getDataFromDataSourceQueryID(dsqId: string) {
+  const tabData: any = Common.tabJson;
+  if (!tabData) {
+    return null;
+  }
+
+  for (const appObject of tabData.AppObjects) {
+    const DSQ = appObject.DataSourceQueries.find(
+      (l: any) => 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: any, appObject: AppObject) {
+  for (const key in response) {
+    const foundObj = appObject.Fields.find((f: any) => 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: string) {
+  const tabData: any = Common.tabJson;
+  return (
+    tabData?.AppObjects.find(
+      (t: { SystemDBTableName: string }) => t.SystemDBTableName === tableName
+    ) || null
+  );
+}