@techextensor/tab-core-utility 2.1.7 → 2.1.9

package/src/lib/tab-core-utility/auth/auth.service.spec.ts

@@ -1,167 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {
-  HttpClientTestingModule,
-  HttpTestingController,
-} from '@angular/common/http/testing';
-import { AuthService } from './auth.service';
-import { ApiService } from '../core/http-client/api.service';
-import { UserResponse } from '../app/interfaces/user.interface';
-import { ApiResponse } from '../app/interfaces/common-api.interface';
-import { LocalStorageService } from './local-storage.service';
-
-describe('AuthService', () => {
-  let authService: AuthService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [AuthService, ApiService, LocalStorageService],
-    });
-    authService = TestBed.inject(AuthService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-  });
-
-  it('should be created', () => {
-    expect(authService).toBeTruthy();
-  });
-
-  it('should fetch user details', () => {
-    const mockUrl = 'mockUrl';
-    const mockResponse: UserResponse = {
-      /* mock user response object */
-      user: {
-        id: '1',
-        email: 'john.doe@example.com',
-        token: 'example_token',
-        username: 'john_doe',
-        bio: 'Sample biography',
-        image: 'https://example.com/profile.jpg',
-      },
-    };
-
-    authService.user(mockUrl).subscribe((response: UserResponse) => {
-      expect(response).toEqual(mockResponse);
-    });
-
-    const request = httpMock.expectOne(mockUrl);
-    expect(request.request.method).toBe('GET');
-    request.flush(mockResponse);
-  });
-
-  it('should sign in with given credentials', () => {
-    const mockUrl = 'mockUrl';
-    const mockCredentials = {
-      /* mock login credentials */
-      email: 'john.doe@example.com',
-      password: '123456',
-    };
-    const mockResponse: UserResponse = {
-      /* mock user response object */
-      user: {
-        id: '1',
-        email: 'john.doe@example.com',
-        token: 'example_token',
-        username: 'john_doe',
-        bio: 'Sample biography',
-        image: 'https://example.com/profile.jpg',
-      },
-    };
-
-    authService
-      .signIn(mockUrl, mockCredentials)
-      .subscribe((response: UserResponse) => {
-        expect(response).toEqual(mockResponse);
-      });
-
-    const request = httpMock.expectOne(mockUrl);
-    expect(request.request.method).toBe('POST');
-    expect(request.request.body).toEqual(mockCredentials);
-    request.flush(mockResponse);
-  });
-
-  it('should register new user with provided credentials', () => {
-    const mockUrl = 'mockUrl';
-    const mockCredentials = {
-      /* mock login credentials */
-      username: 'john.doe',
-      email: 'john.doe@example.com',
-      password: '123456',
-    };
-    const mockResponse: UserResponse = {
-      /* mock user response object */
-      user: {
-        id: '1',
-        email: 'john.doe@example.com',
-        token: 'example_token',
-        username: 'john_doe',
-        bio: 'Sample biography',
-        image: 'https://example.com/profile.jpg',
-      },
-    };
-
-    authService
-      .register(mockUrl, mockCredentials)
-      .subscribe((response: UserResponse) => {
-        expect(response).toEqual(mockResponse);
-      });
-
-    const request = httpMock.expectOne(mockUrl);
-    expect(request.request.method).toBe('POST');
-    expect(request.request.body).toEqual(mockCredentials);
-    request.flush(mockResponse);
-  });
-
-  it('should forgot password in with given credentials', () => {
-    const mockUrl = 'mockUrl';
-    const email = { email: 'test@example.com' };
-    const response: ApiResponse = {
-      requestId: '123456',
-      isSuccess: true,
-      result: [],
-      errors: [],
-    };
-    authService
-      .forgotPassword(mockUrl, email)
-      .subscribe((response: ApiResponse) => {
-        expect(response).toEqual(response);
-      });
-
-    const request = httpMock.expectOne(mockUrl);
-    expect(request.request.method).toBe('POST');
-    expect(request.request.body).toEqual(email);
-    request.flush(response);
-  });
-
-  it('should reset password in with given credentials', () => {
-    const mockUrl = 'mockUrl';
-    const password = { password: '123456' };
-    const response: ApiResponse = {
-      requestId: '123456',
-      isSuccess: true,
-      result: [],
-      errors: [],
-    };
-    authService
-      .resetPassword(mockUrl, password)
-      .subscribe((response: ApiResponse) => {
-        expect(response).toEqual(response);
-      });
-
-    const request = httpMock.expectOne(mockUrl);
-    expect(request.request.method).toBe('POST');
-    expect(request.request.body).toEqual(password);
-    request.flush(response);
-  });
-
-  it('should logout current session', () => {
-    spyOn(localStorage, 'removeItem');
-    const key = 'testKey';
-    authService.logout(key);
-    expect(localStorage.removeItem(key)).toHaveBeenCalled();
-  });
-});

package/src/lib/tab-core-utility/auth/auth.service.ts

@@ -1,91 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { Observable } from 'rxjs';
-import {
-  ForgotPasswordUserRequest,
-  LoginUserRequest,
-  NewUserRequest,
-  ResetPasswordUserRequest,
-} from '../app/interfaces/auth.interface';
-import { UserResponse } from '../app/interfaces/user.interface';
-import { ApiService } from '../core/http-client/api.service';
-import { ApiResponse } from '../app/interfaces/common-api.interface';
-import { LocalStorageService } from './local-storage.service';
-
-@Injectable({ providedIn: 'root' })
-export class AuthService {
-  /**
-   * Injecting required services
-   */
-  private readonly apiService = inject(ApiService);
-  private readonly localStorageService = inject(LocalStorageService);
-
-  // -----------------------------------------------------------------------------------------------------
-  // @ Public methods
-  // -----------------------------------------------------------------------------------------------------
-
-  /**
-   * Fetch user details from the database
-   *
-   * @param endPointName - The End Point Name to fetch user details
-   * @returns Observable<UserResponse> - An observable of UserResponse
-   */
-  user(endPointName: string): Observable<UserResponse> {
-    return this.apiService.get<UserResponse>(endPointName);
-  }
-
-  /**
-   * Sign in with provided credentials
-   *
-   * @param endPointName - The End Point Name to sign in
-   * @param credentials - The login credentials
-   * @returns Observable<UserResponse> - An observable of UserResponse
-   */
-  signIn(endPointName: string, credentials: LoginUserRequest): Observable<UserResponse> {
-    return this.apiService.post<UserResponse, LoginUserRequest>(
-      endPointName,
-      credentials
-    );
-  }
-
-  /**
-   * Register a new user
-   *
-   * @param endPointName - The End Point Name to register a new user
-   * @param credentials - The new user's credentials
-   * @returns Observable<UserResponse> - An observable of UserResponse
-   */
-  register(endPointName: string, credentials: NewUserRequest): Observable<UserResponse> {
-    return this.apiService.post<UserResponse, NewUserRequest>(endPointName, credentials);
-  }
-
-  /**
-   * Forgot password
-   * @param endPointName - The End Point Name of API
-   * @param email - The email of user
-   */
-  forgotPassword(
-    endPointName: string,
-    email: ForgotPasswordUserRequest
-  ): Observable<ApiResponse> {
-    return this.apiService.post(endPointName, email);
-  }
-
-  /**
-   * Reset password
-   * @param endPointName - The End Point Name of API
-   * @param password - The password of user
-   */
-  resetPassword(
-    endPointName: string,
-    password: ResetPasswordUserRequest
-  ): Observable<ApiResponse> {
-    return this.apiService.post(endPointName, password);
-  }
-
-  /**
-   * Logout current session
-   */
-  logout(key: string) {
-    this.localStorageService.removeLocalStorage(key);
-  }
-}

package/src/lib/tab-core-utility/auth/idb-storage.service.ts

@@ -1,77 +0,0 @@
-import { Injectable } from '@angular/core';
-import { openDB, IDBPDatabase, DBSchema } from 'idb';
-
-interface MyDB extends DBSchema {
-    myObjectStore: {
-        key: string;
-        value: { key: string; data: string };
-    };
-}
-
-@Injectable({ providedIn: 'root' })
-export class IdbService {
-    private readonly dbName = 'TabDatabase';
-    private readonly dbVersion = 1;
-    private dbPromise: Promise<IDBPDatabase<MyDB>>;
-
-    constructor() {
-        this.dbPromise = openDB<MyDB>(this.dbName, this.dbVersion, {
-            upgrade(db) {
-                if (!db.objectStoreNames.contains('myObjectStore')) {
-                    db.createObjectStore('myObjectStore', { keyPath: 'key' });
-                }
-            },
-        });
-    }
-
-    async setItem(key: string, data: any): Promise<void> {
-        try {
-            if (data) {
-                await this.setItemIndexedDb(key, data);
-            }
-        } catch (error) {
-            throw new Error('Error storing data: ' + error);
-        }
-    }
-
-    private async setItemIndexedDb(key: string, data: any): Promise<void> {
-        const db = await this.dbPromise;
-        const tx = db.transaction('myObjectStore', 'readwrite');
-        const store = tx.objectStore('myObjectStore');
-        await store.put({ key, data });
-        await tx.done;
-    }
-
-    async getItem(key: string): Promise<any> {
-        try {
-            const result = await this.getItemIndexedDb(key);
-            return result?.data;
-        } catch (error) {
-            throw new Error('Error retrieving data: ' + error);
-        }
-    }
-
-    private async getItemIndexedDb(key: string): Promise<any> {
-        const db = await this.dbPromise;
-        const tx = db.transaction('myObjectStore', 'readonly');
-        const store = tx.objectStore('myObjectStore');
-        const result = await store.get(key);
-        await tx.done;
-        return result;
-    }
-
-    async clearIndexedDB(): Promise<void> {
-        try {
-            const db = await this.dbPromise;
-            const tx = db.transaction('myObjectStore', 'readwrite');
-            const store = tx.objectStore('myObjectStore');
-            await store.clear();
-            await tx.done;
-        } catch (error) {
-            throw new Error('Error clearing IndexedDB: ' + error)
-        }
-    }
-}
-
-
-

package/src/lib/tab-core-utility/auth/local-storage.service.spec.ts

@@ -1,47 +0,0 @@
-import { TestBed, inject } from '@angular/core/testing';
-import { LocalStorageService } from './local-storage.service';
-
-describe('LocalStorageService', () => {
-  let localStorageService: LocalStorageService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [LocalStorageService],
-    });
-  });
-
-  it('should be created', () => {
-    inject([LocalStorageService], (service: LocalStorageService) => {
-      expect(service).toBeTruthy();
-    });
-  });
-
-  it('should set data in local storage', () => {
-    const key = 'testKey';
-    const data = { name: 'John Doe', age: 30 };
-    localStorageService.setLocalStorage(key, data);
-    expect(localStorage.getItem(key)).toEqual(JSON.stringify(data));
-  });
-
-  it('should get data from local storage', () => {
-    const key = 'testKey';
-    const data = { name: 'Jane Smith', age: 25 };
-    localStorage.setItem(key, JSON.stringify(data));
-    const retrievedData = localStorageService.getLocalStorage(key);
-    expect(retrievedData).toEqual(data);
-  });
-
-  it('should return null when getting non-existent data from local storage', () => {
-    const key = 'nonExistentKey';
-    const retrievedData = localStorageService.getLocalStorage(key);
-    expect(retrievedData).toBeNull();
-  });
-
-  it('should remove data from local storage', () => {
-    const key = 'testKey';
-    const data = { city: 'New York', population: 8000000 };
-    localStorage.setItem(key, JSON.stringify(data));
-    localStorageService.removeLocalStorage(key);
-    expect(localStorage.getItem(key)).toBeNull();
-  });
-});

package/src/lib/tab-core-utility/auth/local-storage.service.ts

@@ -1,46 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Injectable } from '@angular/core';
-
-@Injectable({ providedIn: 'root' })
-export class LocalStorageService {
-  // -----------------------------------------------------------------------------------------------------
-  // @ Public methods
-  // -----------------------------------------------------------------------------------------------------
-
-  /**
-   * Set data in local storage
-   * @param key - Key to store the data
-   * @param data - Data to be stored
-   */
-  setLocalStorage = (key: string, data: any): void => {
-    // localStorage.setItem(key, JSON.stringify(data));
-    if (typeof data === 'string') {
-      localStorage.setItem(key, data);
-    } else {
-      localStorage.setItem(key, JSON.stringify(data));
-    }
-  };
-
-  /**
-   * Get data from local storage
-   * @param key - Key to retrieve the data
-   * @returns The data stored in local storage
-   */
-  getLocalStorage = (key: string): any => {
-    const data = localStorage.getItem(key);
-    return data ? data: null;
-    // if (typeof data === 'string') {
-    //   return data ? data: null;
-    // } else {
-    //   return data ? JSON.parse(data) : null;
-    // }
-  };
-
-  /**
-   * Remove data from local storage
-   * @param key - Key of the data to be removed
-   */
-  removeLocalStorage = (key: string): void => {
-    localStorage.removeItem(key);
-  };
-}

package/src/lib/tab-core-utility/auth/session-storage.service.spec.ts

@@ -1,47 +0,0 @@
-import { TestBed, inject } from '@angular/core/testing';
-import { SessionStorageService } from './session-storage.service';
-
-describe('SessionStorageService', () => {
-  let sessionStorageService: SessionStorageService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [SessionStorageService],
-    });
-  });
-
-  it('should be created', () => {
-    inject([SessionStorageService], (service: SessionStorageService) => {
-      expect(service).toBeTruthy();
-    });
-  });
-
-  it('should set data in session storage', () => {
-    const key = 'testKey';
-    const data = { name: 'John Doe', age: 30 };
-    sessionStorageService.setSessionStorage(key, data);
-    expect(sessionStorage.getItem(key)).toEqual(JSON.stringify(data));
-  });
-
-  it('should get data from session storage', () => {
-    const key = 'testKey';
-    const data = { name: 'Jane Smith', age: 25 };
-    sessionStorage.setItem(key, JSON.stringify(data));
-    const retrievedData = sessionStorageService.getSessionStorage(key);
-    expect(retrievedData).toEqual(data);
-  });
-
-  it('should return null when getting non-existent data from session storage', () => {
-    const key = 'nonExistentKey';
-    const retrievedData = sessionStorageService.getSessionStorage(key);
-    expect(retrievedData).toBeNull();
-  });
-
-  it('should remove data from session storage', () => {
-    const key = 'testKey';
-    const data = { city: 'New York', population: 8000000 };
-    sessionStorage.setItem(key, JSON.stringify(data));
-    sessionStorageService.removeSessionStorage(key);
-    expect(sessionStorage.getItem(key)).toBeNull();
-  });
-});

package/src/lib/tab-core-utility/auth/session-storage.service.ts

@@ -1,46 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Injectable } from '@angular/core';
-
-@Injectable({ providedIn: 'root' })
-export class SessionStorageService {
-  // -----------------------------------------------------------------------------------------------------
-  // @ Public methods
-  // -----------------------------------------------------------------------------------------------------
-
-  /**
-   * Set data in session storage
-   * @param key - Key to store the data
-   * @param data - Data to be stored
-   */
-  setSessionStorage = (key: string, data: any): void => {
-    // sessionStorage.setItem(key, JSON.stringify(data));
-    if (typeof data === 'string') {
-      sessionStorage.setItem(key, data);
-    } else {
-      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
-   */
-  getSessionStorage = (key: string): any => {
-    const data = sessionStorage.getItem(key);
-    return data ? data: null;
-    // if (typeof data === 'string') {
-    //   return data ? data: null;
-    // } else {
-    //   return data ? JSON.parse(data) : null;
-    // }
-  };
-
-  /**
-   * Remove data from session storage
-   * @param key - Key of the data to be removed
-   */
-  removeSessionStorage = (key: string): void => {
-    sessionStorage.removeItem(key);
-  };
-}

package/src/lib/tab-core-utility/core/error-handler/error-handler-interceptor.service.ts

@@ -1,32 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { HttpErrorResponse, HttpEvent, HttpHandlerFn, HttpRequest } from '@angular/common/http';
-import { inject } from '@angular/core';
-import { Observable, throwError } from 'rxjs';
-import { catchError } from 'rxjs/operators';
-import { ErrorHandlerStore } from './error-handler.store';
-
-export const errorHandlingInterceptor = (
-  request: HttpRequest<any>,
-  next: HttpHandlerFn,
-): Observable<HttpEvent<any>> => {
-  const errorHandlerStore = inject(ErrorHandlerStore);
-
-  return next(request).pipe(
-    catchError((error) => {
-      if (error instanceof HttpErrorResponse) {
-        switch (error.status) {
-          case 401:
-            errorHandlerStore.handleError401(error);
-            break;
-          case 404:
-            errorHandlerStore.handleError404(error);
-            break;
-          default:
-            throwError(() => error);
-            break;
-        }
-      }
-      return throwError(() => error);
-    }),
-  );
-};

package/src/lib/tab-core-utility/core/error-handler/error-handler.store.spec.ts

@@ -1,16 +0,0 @@
-import { inject, TestBed } from '@angular/core/testing';
-
-import { ErrorHandlerStore } from './error-handler.store';
-import { provideMockStore } from '@ngrx/store/testing';
-
-describe('ErrorHandlerStore', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [ErrorHandlerStore, provideMockStore({})],
-    });
-  });
-
-  it('should be created', inject([ErrorHandlerStore], (service: typeof ErrorHandlerStore) => {
-    expect(service).toBeTruthy();
-  }));
-});

package/src/lib/tab-core-utility/core/error-handler/error-handler.store.ts

@@ -1,26 +0,0 @@
-import { signalStore, withState, withMethods, patchState } from '@ngrx/signals';
-import { inject } from '@angular/core';
-import { Router } from '@angular/router';
-import { ErrorHandlerState, errorHandlerInitialState } from './models/error-handler.state';
-import { HttpErrorResponse } from '@angular/common/http';
-
-export const ErrorHandlerStore = signalStore(
-  { providedIn: 'root' },
-  withState<ErrorHandlerState>(errorHandlerInitialState),
-  withMethods((store, router = inject(Router)) => ({
-    handleError401: (error: HttpErrorResponse) => {
-      patchState(store, {
-        code: error.status,
-        message: error.message,
-      });
-      router.navigate(['/login']);
-    },
-    handleError404: (error: HttpErrorResponse) => {
-      patchState(store, {
-        code: error.status,
-        message: error.message,
-      });
-      router.navigate(['/']);
-    },
-  })),
-);

package/src/lib/tab-core-utility/core/error-handler/models/error-handler.state.ts

@@ -1,9 +0,0 @@
-export interface ErrorHandlerState {
-  code: number;
-  message: string | undefined;
-}
-
-export const errorHandlerInitialState: ErrorHandlerState = {
-  message: undefined,
-  code: -1,
-};

package/src/lib/tab-core-utility/core/http-client/api-url.token.ts

@@ -1,4 +0,0 @@
-import { InjectionToken } from '@angular/core';
-
-export const API_URL = new InjectionToken<string>('API_URL');
-export const Workflow_URL = new InjectionToken<string>('Workflow_URL');

package/src/lib/tab-core-utility/core/http-client/api.service.spec.ts

@@ -1,18 +0,0 @@
-import { TestBed, inject } from '@angular/core/testing';
-import { HttpClientTestingModule } from '@angular/common/http/testing';
-
-import { ApiService } from './api.service';
-import { API_URL } from './api-url.token';
-
-describe('ApiService', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [ApiService, { provide: API_URL, useValue: 'api_url' }],
-    });
-  });
-
-  it('should be created', inject([ApiService], (service: ApiService) => {
-    expect(service).toBeTruthy();
-  }));
-});