@techextensor/tab-core-utility 2.2.193 → 2.2.194

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

@@ -1,4 +1,90 @@
+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);
+}
+// function waitForData(timeout = 5000): Promise<void> {
+//   return new Promise((resolve, reject) => {
+//     const interval = 100; // Check every 100ms
+//     let waited = 0;
+//     const checkData = () => {
+//       if (Common.tabJson) {
+//         resolve();
+//       } else if (waited >= timeout) {
+//         reject(new Error('Timeout waiting for Common.tabJson'));
+//       } else {
+//         waited += interval;
+//         setTimeout(checkData, interval);
+//       }
+//     };
+//     checkData();
+//   });
+// }
+/**
+ * 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
  *
@@ -16,4 +102,81 @@ export function syncAppObjectFields(response, appObject) {
     }
     return response;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 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);
+}
+/**
+ * Get the fields based on the appobjectid
+ *
+ * @param appObjectId - The appobjectid
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppfieldsFromAppObjectId(appObjectId) {
+    const tabData = Common.tabJson;
+    const findAppObject = tabData?.AppObjects.find((t) => t.ID === appObjectId) || null;
+    if (findAppObject) {
+        return findAppObject.Fields;
+    }
+    else {
+        return null;
+    }
+}
+export function getLookupAppfieldsFromAppObjectId(appObjectId) {
+    const tabData = Common.tabJson;
+    const findAppObject = tabData?.AppObjects.find((t) => t.ID === appObjectId) || null;
+    if (findAppObject) {
+        const lookupFields = findAppObject.Fields.filter((t) => t.LookUpDetails);
+        if (lookupFields) {
+            return lookupFields;
+        }
+        else {
+            return null;
+        }
+    }
+}
+export function getViewAppObjectDetailsFromDSQID(dsqID) {
+    const appObject = getAppObjectFromDataSourceQueryID(dsqID);
+    let viewAppObjectDetailsOfGrid = appObject;
+    // check appobject is table or view
+    if (appObject && appObject.ObjectType == 2) {
+        viewAppObjectDetailsOfGrid = getAppObject(appObject?.CRUDAppObjectId);
+    }
+    return viewAppObjectDetailsOfGrid;
+}
+/**
+ * Retrieves all appObjects and their DSQs in a single list
+ * suitable for tree view representation.
+ * @author : Parth B Thakkar
+ * @Usage : HTTP Request
+ * @returns Array<{ id: string; name: string; hasChildren: boolean; parentID: string | null }>
+ */
+export function getAllAppObjectsForTreeViewJson() {
+    const tabData = Common.tabJson;
+    const fieldData = [];
+    for (const appObject of tabData?.AppObjects || []) {
+        fieldData.push({
+            id: appObject.ID,
+            name: appObject.DisplayName,
+            hasChildren: true,
+            parentID: null,
+        });
+        // looping children
+        for (const dsq of appObject.DataSourceQueries) {
+            fieldData.push({
+                id: dsq.ID,
+                name: dsq.DisplayName,
+                hasChildren: false,
+                parentID: appObject.ID,
+            });
+        }
+    }
+    return fieldData.sort((a, b) => a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1);
+}
+//# 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":["import { 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// function waitForData(timeout = 5000): Promise<void> {\r\n//   return new Promise((resolve, reject) => {\r\n//     const interval = 100; // Check every 100ms\r\n//     let waited = 0;\r\n\r\n//     const checkData = () => {\r\n//       if (Common.tabJson) {\r\n//         resolve();\r\n//       } else if (waited >= timeout) {\r\n//         reject(new Error('Timeout waiting for Common.tabJson'));\r\n//       } else {\r\n//         waited += interval;\r\n//         setTimeout(checkData, interval);\r\n//       }\r\n//     };\r\n\r\n//     checkData();\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\r\n/**\r\n * Get the fields based on the appobjectid\r\n *\r\n * @param appObjectId - The appobjectid\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\nexport function getAppfieldsFromAppObjectId(appObjectId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  const findAppObject =\r\n    tabData?.AppObjects.find((t: any) => t.ID === appObjectId) || null;\r\n  if (findAppObject) {\r\n    return findAppObject.Fields;\r\n  } else {\r\n    return null;\r\n  }\r\n}\r\n\r\nexport function getLookupAppfieldsFromAppObjectId(appObjectId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  const findAppObject =\r\n    tabData?.AppObjects.find((t: any) => t.ID === appObjectId) || null;\r\n  if (findAppObject) {\r\n    const lookupFields = findAppObject.Fields.filter(\r\n      (t: any) => t.LookUpDetails\r\n    );\r\n    if (lookupFields) {\r\n      return lookupFields;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n}\r\nexport function getViewAppObjectDetailsFromDSQID(dsqID: string) {\r\n  const appObject = getAppObjectFromDataSourceQueryID(dsqID);\r\n  let viewAppObjectDetailsOfGrid = appObject;\r\n  // check appobject is table or view\r\n  if (appObject && appObject.ObjectType == 2) {\r\n    viewAppObjectDetailsOfGrid = getAppObject(appObject?.CRUDAppObjectId);\r\n  }\r\n  return viewAppObjectDetailsOfGrid;\r\n}\r\n\r\n/**\r\n * Retrieves all appObjects and their DSQs in a single list\r\n * suitable for tree view representation.\r\n * @author : Parth B Thakkar\r\n * @Usage : HTTP Request\r\n * @returns Array<{ id: string; name: string; hasChildren: boolean; parentID: string | null }>\r\n */\r\nexport function getAllAppObjectsForTreeViewJson() {\r\n  const tabData = Common.tabJson;\r\n\r\n  const fieldData: Array<{\r\n    id: string; // UUID as a string\r\n    name: string; // Name of the node\r\n    hasChildren: boolean; // Whether the node has children\r\n    parentID: string | null; // Parent ID if applicable, otherwise null\r\n  }> = [];\r\n  for (const appObject of tabData?.AppObjects || []) {\r\n    fieldData.push({\r\n      id: appObject.ID,\r\n      name: appObject.DisplayName,\r\n      hasChildren: true,\r\n      parentID: null,\r\n    });\r\n    // looping children\r\n    for (const dsq of appObject.DataSourceQueries) {\r\n      fieldData.push({\r\n        id: dsq.ID,\r\n        name: dsq.DisplayName,\r\n        hasChildren: false,\r\n        parentID: appObject.ID,\r\n      });\r\n    }\r\n  }\r\n  return fieldData.sort((a, b) =>\r\n    a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1\r\n  );\r\n}\r\n"]}

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

@@ -1,10 +1,7 @@
 import { Injectable, inject } from '@angular/core';
-import { map } from 'rxjs/operators';
 import { ApiService } from '../core/http-client/api.service';
-import { getHeaders } from '../app/utils/req-res.util';
-import { API, APIServices } from '../app/constants/api-constants';
-import { AuthResponseAdapter } from '../app/helpers/auth-response.adapter';
-import { LoginResponseAdapter } from '../app/helpers/login-response.adapter';
+import { getFormDataHeaders, getHeaders } from '../app/utils/req-res.util';
+import { API } from '../app/constants/api-constants';
 import * as i0 from "@angular/core";
 export class AuthService {
     constructor() {
@@ -13,6 +10,9 @@ export class AuthService {
          */
         this.apiService = inject(ApiService);
     }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Public methods
+    // -----------------------------------------------------------------------------------------------------
     // /**
     //  * Fetch user details from the database
     //  *
@@ -28,7 +28,7 @@ export class AuthService {
      * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse
      */
     signIn(credentials) {
-        return this.apiService.postToService(APIServices.identityService, API.login, credentials).pipe(map(response => LoginResponseAdapter.normalize(response)));
+        return this.apiService.post(API.login, credentials);
     }
     /**
      * Register tenant
@@ -41,41 +41,16 @@ export class AuthService {
     }
     /**
      * Register a new user
-     * Uses new identity service endpoint: POST auth/register
      * @param credentials - The new user's credentials
      * @param headers - The headers
      * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse
      */
     register(credentials, headers) {
-        headers = getHeaders(headers);
-        const transformedPayload = this.transformRegisterRequest(credentials);
-        return this.apiService.postToService(APIServices.identityService, API.authRegisterUser, transformedPayload, headers).pipe(map(response => AuthResponseAdapter.normalize(response)));
-    }
-    /**
-     * Transforms register request payload from PascalCase to camelCase for new identity service.
-     * { FirstName, LastName, Email, Password, ... } → { firstName, lastName, email, password, ... }
-     */
-    transformRegisterRequest(data) {
-        if (!data)
-            return data;
-        // If data already has camelCase keys, skip transform
-        if (data.email && !data.Email)
-            return data;
-        const fieldMap = {
-            FirstName: 'firstName',
-            LastName: 'lastName',
-            Email: 'email',
-            Password: 'password',
-            PhoneNumber: 'phoneNumber',
-            IsEnabled: 'isEnabled',
-            Role: 'role',
-            Username: 'username',
-        };
-        const transformed = {};
-        for (const key of Object.keys(data)) {
-            transformed[fieldMap[key] || key] = data[key];
+        if (!headers) {
+            // Get the headers for FormData
+            headers = getFormDataHeaders();
         }
-        return transformed;
+        return this.apiService.post(API.registerUser, credentials, headers);
     }
     // /**
     //  * Forgot password
@@ -140,4 +115,4 @@ export class AuthService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../libs/data-access/src/lib/tab-core-utility/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport {\r\n  ChangePasswordUserRequest,\r\n  LoginUserRequest,\r\n  NewUserRequest,\r\n  RefreshTokenRequest,\r\n  RegisterTenant,\r\n  ResetPasswordUserRequest,\r\n  UserDetailsRequest,\r\n} from '../app/interfaces/auth.interface';\r\nimport { ApiService } from '../core/http-client/api.service';\r\nimport { CommonApiResponse } from '../app/interfaces/common.interface';\r\nimport { getHeaders } from '../app/utils/req-res.util';\r\nimport { API, APIServices } from '../app/constants/api-constants';\r\nimport { AuthResponseAdapter } from '../app/helpers/auth-response.adapter';\r\nimport { LoginResponseAdapter } from '../app/helpers/login-response.adapter';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class AuthService {\r\n  /**\r\n   * Injecting required services\r\n   */\r\n  private readonly apiService = inject(ApiService);\r\n\r\n  // /**\r\n  //  * Fetch user details from the database\r\n  //  *\r\n  //  * @param endPointName - The End Point Name to fetch user details\r\n  //  * @returns Observable<UserResponse> - An observable of UserResponse\r\n  //  */\r\n  // user(endPointName: string): Observable<UserResponse> {\r\n  //   return this.apiService.get<UserResponse>(endPointName);\r\n  // }\r\n\r\n  /**\r\n   * Sign in with provided credentials\r\n   * @param credentials - The login credentials\r\n   * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse\r\n   */\r\n  signIn(credentials: LoginUserRequest): Observable<CommonApiResponse> {\r\n    return this.apiService.postToService<CommonApiResponse, LoginUserRequest>(\r\n      APIServices.identityService,\r\n      API.login,\r\n      credentials\r\n    ).pipe(\r\n      map(response => LoginResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Register tenant\r\n   * @param credentials - The credentials\r\n   * @returns Observable<CommonApiResponse>\r\n   */\r\n  registerTenant(credentials: RegisterTenant): Observable<CommonApiResponse> {      \r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, RegisterTenant>(\r\n      API.RegisterTenant,\r\n      credentials,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Register a new user\r\n   * Uses new identity service endpoint: POST auth/register\r\n   * @param credentials - The new user's credentials\r\n   * @param headers - The headers\r\n   * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse\r\n   */\r\n  register(credentials: NewUserRequest, headers?: any): Observable<CommonApiResponse> {\r\n    headers = getHeaders(headers);\r\n    const transformedPayload = this.transformRegisterRequest(credentials);\r\n    return this.apiService.postToService(\r\n      APIServices.identityService,\r\n      API.authRegisterUser,\r\n      transformedPayload,\r\n      headers\r\n    ).pipe(\r\n      map(response => AuthResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Transforms register request payload from PascalCase to camelCase for new identity service.\r\n   * { FirstName, LastName, Email, Password, ... } → { firstName, lastName, email, password, ... }\r\n   */\r\n  private transformRegisterRequest(data: any): any {\r\n    if (!data) return data;\r\n\r\n    // If data already has camelCase keys, skip transform\r\n    if (data.email && !data.Email) return data;\r\n\r\n    const fieldMap: Record<string, string> = {\r\n      FirstName: 'firstName',\r\n      LastName: 'lastName',\r\n      Email: 'email',\r\n      Password: 'password',\r\n      PhoneNumber: 'phoneNumber',\r\n      IsEnabled: 'isEnabled',\r\n      Role: 'role',\r\n      Username: 'username',\r\n    };\r\n\r\n    const transformed: any = {};\r\n    for (const key of Object.keys(data)) {\r\n      transformed[fieldMap[key] || key] = data[key];\r\n    }\r\n    return transformed;\r\n  }\r\n\r\n  // /**\r\n  //  * Forgot password\r\n  //  * @param endPointName - The End Point Name of API\r\n  //  * @param email - The email of user\r\n  //  */\r\n  // forgotPassword(\r\n  //   endPointName: string,\r\n  //   email: ForgotPasswordUserRequest\r\n  // ): Observable<ApiResponse> {\r\n  //   return this.apiService.post(endPointName, email);\r\n  // }\r\n\r\n  /**\r\n   * Reset Password\r\n   * @param data - Data for resetting password\r\n   * @returns Response from the API\r\n   */\r\n  resetPassword(data: ResetPasswordUserRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, ResetPasswordUserRequest>(API.restpassword, data, headers);\r\n  }\r\n\r\n  /**\r\n  * Change Password\r\n  * @param data - Data for changing password\r\n  * @returns Response from the API\r\n  */\r\n  changePassword(data: ChangePasswordUserRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.changePassword, data, headers);\r\n  }\r\n\r\n  // /**\r\n  //  * Logout current session\r\n  //  */\r\n  // logout(key: string) {\r\n  //   this.localStorageService.removeLocalStorage(key);\r\n  // }\r\n\r\n  /**\r\n   * Refreshes the access token using the refresh token\r\n   * @param data - The refresh token request data\r\n   * @returns Observable<CommonApiResponse> - An observable of the response from the API\r\n   */\r\n  refreshToken(data: RefreshTokenRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, RefreshTokenRequest>(API.refreshToken, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Fetches user details based on the provided identity\r\n   * @param data - The user details request data\r\n   * @param headers - Optional headers for the request\r\n   * @returns Observable<CommonApiResponse> - An observable of the user details\r\n   */\r\n  getUserDetails(data: UserDetailsRequest, headers?: any): Observable<CommonApiResponse> {\r\n    if (!headers) {\r\n       headers =getHeaders(headers);\r\n    } \r\n    return this.apiService.post<CommonApiResponse, UserDetailsRequest>(API.getUserDetails, data, headers);\r\n  }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../libs/data-access/src/lib/tab-core-utility/auth/auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAWnD,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,GAAG,EAAE,MAAM,gCAAgC,CAAC;;AAGrD,MAAM,OAAO,WAAW;IADxB;QAEE;;WAEG;QACc,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;KAqHlD;IAnHC,wGAAwG;IACxG,mBAAmB;IACnB,wGAAwG;IAExG,MAAM;IACN,0CAA0C;IAC1C,KAAK;IACL,oEAAoE;IACpE,uEAAuE;IACvE,MAAM;IACN,yDAAyD;IACzD,4DAA4D;IAC5D,IAAI;IAEJ;;;;OAIG;IACH,MAAM,CAAC,WAA6B;QAClC,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CACzB,GAAG,CAAC,KAAK,EACT,WAAW,CACZ,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,WAA2B;QACxC,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CACzB,GAAG,CAAC,cAAc,EAClB,WAAW,EACX,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,WAA2B,EAAE,OAAa;QACjD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,+BAA+B;YAC/B,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACjC,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAoC,GAAG,CAAC,YAAY,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IACzG,CAAC;IAED,MAAM;IACN,qBAAqB;IACrB,qDAAqD;IACrD,sCAAsC;IACtC,MAAM;IACN,kBAAkB;IAClB,0BAA0B;IAC1B,qCAAqC;IACrC,+BAA+B;IAC/B,sDAAsD;IACtD,IAAI;IAEJ;;;;OAIG;IACH,aAAa,CAAC,IAA8B;QAC1C,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAA8C,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5G,CAAC;IAED;;;;MAIE;IACF,cAAc,CAAC,IAA+B;QAC5C,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAED,MAAM;IACN,4BAA4B;IAC5B,MAAM;IACN,wBAAwB;IACxB,sDAAsD;IACtD,IAAI;IAEJ;;;;OAIG;IACH,YAAY,CAAC,IAAyB;QACpC,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAyC,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACvG,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAwB,EAAE,OAAa;QACpD,IAAI,CAAC,OAAO,EAAE,CAAC;YACZ,OAAO,GAAE,UAAU,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAwC,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACxG,CAAC;4EAxHU,WAAW;uEAAX,WAAW,WAAX,WAAW,mBADE,MAAM;;iFACnB,WAAW;cADvB,UAAU;eAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, inject } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport {\r\n  ChangePasswordUserRequest,\r\n  LoginUserRequest,\r\n  NewUserRequest,\r\n  RefreshTokenRequest,\r\n  RegisterTenant,\r\n  ResetPasswordUserRequest,\r\n  UserDetailsRequest,\r\n} from '../app/interfaces/auth.interface';\r\nimport { ApiService } from '../core/http-client/api.service';\r\nimport { CommonApiResponse } from '../app/interfaces/common.interface';\r\nimport { getFormDataHeaders, getHeaders } from '../app/utils/req-res.util';\r\nimport { API } from '../app/constants/api-constants';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class AuthService {\r\n  /**\r\n   * Injecting required services\r\n   */\r\n  private readonly apiService = inject(ApiService);\r\n\r\n  // -----------------------------------------------------------------------------------------------------\r\n  // @ Public methods\r\n  // -----------------------------------------------------------------------------------------------------\r\n\r\n  // /**\r\n  //  * Fetch user details from the database\r\n  //  *\r\n  //  * @param endPointName - The End Point Name to fetch user details\r\n  //  * @returns Observable<UserResponse> - An observable of UserResponse\r\n  //  */\r\n  // user(endPointName: string): Observable<UserResponse> {\r\n  //   return this.apiService.get<UserResponse>(endPointName);\r\n  // }\r\n\r\n  /**\r\n   * Sign in with provided credentials\r\n   * @param credentials - The login credentials\r\n   * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse\r\n   */\r\n  signIn(credentials: LoginUserRequest): Observable<CommonApiResponse> {\r\n    return this.apiService.post<CommonApiResponse, LoginUserRequest>(\r\n      API.login,\r\n      credentials\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Register tenant\r\n   * @param credentials - The credentials\r\n   * @returns Observable<CommonApiResponse>\r\n   */\r\n  registerTenant(credentials: RegisterTenant): Observable<CommonApiResponse> {      \r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, RegisterTenant>(\r\n      API.RegisterTenant,\r\n      credentials,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Register a new user\r\n   * @param credentials - The new user's credentials\r\n   * @param headers - The headers\r\n   * @returns Observable<CommonApiResponse> - An observable of CommonApiResponse\r\n   */\r\n  register(credentials: NewUserRequest, headers?: any): Observable<CommonApiResponse> {\r\n    if (!headers) {\r\n      // Get the headers for FormData\r\n      headers = getFormDataHeaders();\r\n    }\r\n    return this.apiService.post<CommonApiResponse, NewUserRequest>(API.registerUser, credentials, headers);\r\n  }\r\n\r\n  // /**\r\n  //  * Forgot password\r\n  //  * @param endPointName - The End Point Name of API\r\n  //  * @param email - The email of user\r\n  //  */\r\n  // forgotPassword(\r\n  //   endPointName: string,\r\n  //   email: ForgotPasswordUserRequest\r\n  // ): Observable<ApiResponse> {\r\n  //   return this.apiService.post(endPointName, email);\r\n  // }\r\n\r\n  /**\r\n   * Reset Password\r\n   * @param data - Data for resetting password\r\n   * @returns Response from the API\r\n   */\r\n  resetPassword(data: ResetPasswordUserRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, ResetPasswordUserRequest>(API.restpassword, data, headers);\r\n  }\r\n\r\n  /**\r\n  * Change Password\r\n  * @param data - Data for changing password\r\n  * @returns Response from the API\r\n  */\r\n  changePassword(data: ChangePasswordUserRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.changePassword, data, headers);\r\n  }\r\n\r\n  // /**\r\n  //  * Logout current session\r\n  //  */\r\n  // logout(key: string) {\r\n  //   this.localStorageService.removeLocalStorage(key);\r\n  // }\r\n\r\n  /**\r\n   * Refreshes the access token using the refresh token\r\n   * @param data - The refresh token request data\r\n   * @returns Observable<CommonApiResponse> - An observable of the response from the API\r\n   */\r\n  refreshToken(data: RefreshTokenRequest): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post<CommonApiResponse, RefreshTokenRequest>(API.refreshToken, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Fetches user details based on the provided identity\r\n   * @param data - The user details request data\r\n   * @param headers - Optional headers for the request\r\n   * @returns Observable<CommonApiResponse> - An observable of the user details\r\n   */\r\n  getUserDetails(data: UserDetailsRequest, headers?: any): Observable<CommonApiResponse> {\r\n    if (!headers) {\r\n       headers =getHeaders(headers);\r\n    } \r\n    return this.apiService.post<CommonApiResponse, UserDetailsRequest>(API.getUserDetails, data, headers);\r\n  }\r\n}"]}

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

@@ -1,10 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Injectable, inject } from '@angular/core';
 import { HttpClient, HttpParams } from '@angular/common/http';
-import { map } from 'rxjs/operators';
 import { API_URL } from './api-url.token';
-import { Common } from '../../app/constants/common';
-import { ResponseAdapter } from '../../app/helpers/response.adapter';
 import * as i0 from "@angular/core";
 export class ApiService {
     constructor() {
@@ -124,80 +121,6 @@ export class ApiService {
     deleteByUrl(url, options) {
         return this.http.delete(url, { ...options });
     }
-    // ==================== NEW MICROSERVICE METHODS ====================
-    /**
-     * Makes an HTTP GET request to a specific microservice
-     * @param serviceName - Name of the microservice (e.g., 'crudService', 'metadataService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param params - Query parameters for the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    getFromService(serviceName, endPointName, params = new HttpParams(), reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.get(`${serviceUrl}${endPointName}`, {
-            headers: reqHeader,
-            params,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP POST request to a specific microservice
-     * @param serviceName - Name of the microservice (e.g., 'crudService', 'formioService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    postToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP PUT request to a specific microservice
-     * @param serviceName - Name of the microservice
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    putToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.put(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP DELETE request to a specific microservice
-     * @param serviceName - Name of the microservice
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request (optional, for DELETE with body)
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    deleteFromService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.delete(`${serviceUrl}${endPointName}`, {
-            headers: reqHeader,
-            body: data ? JSON.stringify(data) : undefined
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP POST request to a specific microservice and returns a Blob response
-     * @param serviceName - Name of the microservice (e.g., 'reportService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response as a Blob
-     */
-    postBlobToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-            responseType: 'blob'
-        });
-    }
     static { this.ɵfac = function ApiService_Factory(t) { return new (t || ApiService)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApiService, factory: ApiService.ɵfac, providedIn: 'root' }); }
 }
@@ -205,4 +128,4 @@ export class ApiService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/http-client/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { API_URL } from './api-url.token';\r\nimport { Common } from '../../app/constants/common';\r\nimport { APIServiceName, CommonApiResponse, StandardApiResponse } from '../../app/interfaces/common.interface';\r\nimport { ResponseAdapter } from '../../app/helpers/response.adapter';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ApiService {\r\n  private readonly http = inject(HttpClient);\r\n  private readonly api_url = inject(API_URL);\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param endPointName The URL for the HTTP GET request.\r\n   * @param params The query parameters for the request (default is an empty HttpParams object).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  get<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data to the specified URL.\r\n   * @param endPointName The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  post<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<D | any> {\r\n    return this.http.post<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to update data at the specified URL.\r\n   * @param endPointName The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  put<T, D>(\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.put<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to delete data from the specified URL.\r\n   * @param endPointName The URL for the HTTP DELETE request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  delete<T>(endPointName: string, reqHeader?: HttpHeaders): Observable<any> {\r\n    return this.http.delete<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param params The query parameters for the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  getBlob<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data and retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  postBlob<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.post<T>(`${this.api_url}${endPointName}`, data, {\r\n      headers: reqHeader,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param url The URL for the HTTP GET request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  getByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.get<T>(url, { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to the specified URL.\r\n   * @param url The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  postByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.post<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to the specified URL.\r\n   * @param url The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  putByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.put<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to the specified URL.\r\n   * @param url The URL for the HTTP DELETE request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  deleteByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.delete<T>(url, { ...options });\r\n  }\r\n\r\n  // ==================== NEW MICROSERVICE METHODS ====================\r\n\r\n  /**\r\n   * Makes an HTTP GET request to a specific microservice\r\n   * @param serviceName - Name of the microservice (e.g., 'crudService', 'metadataService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param params - Query parameters for the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  getFromService(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.get<StandardApiResponse>(`${serviceUrl}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    }).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to a specific microservice\r\n   * @param serviceName - Name of the microservice (e.g., 'crudService', 'formioService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  postToService<T, D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.post<StandardApiResponse>(\r\n      `${serviceUrl}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    ).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to a specific microservice\r\n   * @param serviceName - Name of the microservice\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  putToService<T, D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.put<StandardApiResponse>(\r\n      `${serviceUrl}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    ).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to a specific microservice\r\n   * @param serviceName - Name of the microservice\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request (optional, for DELETE with body)\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  deleteFromService<D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.delete<StandardApiResponse>(`${serviceUrl}${endPointName}`, {\r\n      headers: reqHeader,\r\n      body: data ? JSON.stringify(data) : undefined\r\n    }).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to a specific microservice and returns a Blob response\r\n   * @param serviceName - Name of the microservice (e.g., 'reportService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response as a Blob\r\n   */\r\n  postBlobToService<D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<Blob> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {\r\n      headers: reqHeader,\r\n      responseType: 'blob'\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/http-client/api.service.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAe,MAAM,sBAAsB,CAAC;AAE3E,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;;AAG1C,MAAM,OAAO,UAAU;IADvB;QAEmB,SAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,YAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;KAwJ5C;IAtJC;;;;;;OAMG;IACH,GAAG,CACD,YAAoB,EACpB,SAAqB,IAAI,UAAU,EAAE,EACrC,SAAuB;QAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAAE;YACxD,OAAO,EAAE,SAAS;YAClB,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CACF,YAAoB,EACpB,IAAQ,EACR,SAAuB;QAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACpB;YACE,OAAO,EAAE,SAAS;SACnB,CACF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CACD,YAAoB,EACpB,IAAO,EACP,SAAuB;QAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAClB,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACpB;YACE,OAAO,EAAE,SAAS;SACnB,CACF,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAI,YAAoB,EAAE,SAAuB;QACrD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAI,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAAE;YAC3D,OAAO,EAAE,SAAS;SACnB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CACL,YAAoB,EACpB,SAAqB,IAAI,UAAU,EAAE,EACrC,SAAuB;QAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAAE;YACxD,OAAO,EAAE,SAAS;YAClB,MAAM;YACN,YAAY,EAAE,MAAgB;SAC/B,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CACN,YAAoB,EACpB,IAAQ,EACR,SAAuB;QAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,EAAE,IAAI,EAAE;YAC/D,OAAO,EAAE,SAAS;YAClB,YAAY,EAAE,MAAgB;SAC/B,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAI,GAAW,EAAE,OAAa;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,GAAG,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,SAAS,CAAO,GAAW,EAAE,IAAQ,EAAE,OAAa;QAClD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAO,GAAW,EAAE,IAAQ,EAAE,OAAa;QACjD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACrE,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAI,GAAW,EAAE,OAAa;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAI,GAAG,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAClD,CAAC;2EAzJU,UAAU;uEAAV,UAAU,WAAV,UAAU,mBADG,MAAM;;iFACnB,UAAU;cADtB,UAAU;eAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { API_URL } from './api-url.token';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ApiService {\r\n  private readonly http = inject(HttpClient);\r\n  private readonly api_url = inject(API_URL);\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param endPointName The URL for the HTTP GET request.\r\n   * @param params The query parameters for the request (default is an empty HttpParams object).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  get<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data to the specified URL.\r\n   * @param endPointName The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  post<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<D | any> {\r\n    return this.http.post<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to update data at the specified URL.\r\n   * @param endPointName The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  put<T, D>(\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.put<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to delete data from the specified URL.\r\n   * @param endPointName The URL for the HTTP DELETE request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  delete<T>(endPointName: string, reqHeader?: HttpHeaders): Observable<any> {\r\n    return this.http.delete<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param params The query parameters for the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  getBlob<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data and retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  postBlob<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.post<T>(`${this.api_url}${endPointName}`, data, {\r\n      headers: reqHeader,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param url The URL for the HTTP GET request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  getByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.get<T>(url, { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to the specified URL.\r\n   * @param url The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  postByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.post<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to the specified URL.\r\n   * @param url The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  putByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.put<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to the specified URL.\r\n   * @param url The URL for the HTTP DELETE request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  deleteByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.delete<T>(url, { ...options });\r\n  }\r\n}\r\n"]}

package/index.d.ts

@@ -24,7 +24,6 @@ export * from './lib/tab-core-utility/app/helpers/common/req-res.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/where-clause.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/template.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/meta-data.helpers';
-export * from './lib/tab-core-utility/app/helpers/login-response.adapter';
 export * from './lib/tab-core-utility/app/helpers/screen/forms.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid-column-data.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid.helpers';
@@ -37,7 +36,6 @@ export * from './lib/tab-core-utility/app/interfaces/user.interface';
 export * from './lib/tab-core-utility/app/interfaces/orgInfo.interface';
 export * from './lib/tab-core-utility/app/interfaces/schema.interface';
 export * from './lib/tab-core-utility/app/interfaces/grid.interface';
-export * from './lib/tab-core-utility/app/interfaces/signalr.interface';
 export * from './lib/tab-core-utility/app/models/api-query.class';
 export * from './lib/tab-core-utility/app/models/app-object.class';
 export * from './lib/tab-core-utility/app/models/common.class';
@@ -58,9 +56,6 @@ export * from './lib/tab-core-utility/core/service/translation.service';
 export * from './lib/tab-core-utility/core/service/notification.service';
 export * from './lib/tab-core-utility/core/service/confirmation.service';
 export * from './lib/tab-core-utility/core/service/encryption.service';
-export * from './lib/tab-core-utility/core/service/signalr/signalr.service';
-export * from './lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service';
-export * from './lib/tab-core-utility/core/service/signalr/operation-tracker.service';
 export * from './lib/tab-core-utility/core/pipe/translate.pipe';
 export * from './lib/tab-core-utility/core/provider/translation.provider';
 export * from './lib/tab-core-utility/core/provider/notification.provider';

package/lib/tab-core-utility/app/constants/api-constants.d.ts

@@ -1,15 +1,18 @@
-import type { APIServiceName } from '../interfaces/common.interface';
 export declare const API: {
     applicationIdentifier: string;
     applicationIdentifierForPMS: string;
     novuBackendUrl: string;
     novuSocketUrl: string;
+    insert: string;
     bulkInsert: string;
+    update: string;
+    delete: string;
     select: string;
-    screen: string;
-    listsGet: string;
+    getDSQ: string;
+    getScreen: string;
+    getListFromDsq: string;
     buildApp: string;
-    metadataSchema: string;
+    getSchema: string;
     login: string;
     pluginUpload: string;
     getFile: string;
@@ -21,37 +24,37 @@ export declare const API: {
     multipleFileUpload: string;
     deleteFile: string;
     getMediaFile: string;
-    auditGetHistory: string;
+    getHistory: string;
     changePassword: string;
     restpassword: string;
     getImage: string;
-    importData: string;
-    screenData: string;
+    pmjayImport: string;
+    getScreenData: string;
     processRequest: string;
-    statusAvailable: string;
-    statusUpdate: string;
-    authRegisterUser: string;
+    getNextStatus: string;
+    updateStatus: string;
+    registerUser: string;
     getUserDetails: string;
     getPermission: string;
     testConnection: string;
     performValidation: string;
     setTabComponents: string;
     BuildFormIOComponents: string;
-    applicationRegisterAppObjects: string;
+    registerAppObjects: string;
     languageResource: string;
     refreshToken: string;
-    globalSearch: string;
+    search: string;
     cloneDsq: string;
     InsertScreenPerformanceAnalytics: string;
     GenerateHttpRequest: string;
     GetDetailOfPerformanceAnalytics: string;
     GetSummaryOfPerformanceAnalytics: string;
     GetDataJsonByType: string;
-    applicationSyncAppFields: string;
-    reportExport: string;
+    SyncAppFields: string;
+    exportReport: string;
     RefreshGlobalSearchData: string;
     RefreshRecordInfoData: string;
-    reportDownload: string;
+    downloadReportFile: string;
     sendReport: string;
     GetReleaseJSONDifference: string;
     GetDataDifference: string;
@@ -60,14 +63,4 @@ export declare const API: {
     GetAllDocumnets: string;
     GetDocumentById: string;
     ExecuteWorkflow: string;
-    QueriesExecute: string;
-    QueriesSelect: string;
-    recordsInsert: string;
-    recordsUpdate: string;
-    recordsDelete: string;
-    fileManagerFileOperations: string;
-    fileManagerGetImage: string;
-    fileManagerUpload: string;
-    fileManagerDownload: string;
 };
-export declare const APIServices: Record<APIServiceName, APIServiceName>;

package/lib/tab-core-utility/app/constants/common.d.ts

@@ -1,4 +1,3 @@
-import { APIServiceUrls } from '../interfaces/common.interface';
 export declare class Common {
     static environmentName: string;
     static applicationCode: string;
@@ -8,13 +7,5 @@ export declare class Common {
     static tabAppObjectAccess: any;
     static staticToken: any;
     static i18n: any;
-    /** Microservice URLs configuration - NEW for microservices architecture */
-    static apiServiceUrls: APIServiceUrls;
-    /** SignalR hub URL for real-time notifications */
-    static signalRHubUrl: string;
-    /**
-     * Initialize the static variables
-     * Called once at application startup from the main app
-     */
     static init(environment: any): void;
 }