@corp-products/app-core 0.0.1

package/src/lib/core/services/base-http-service/http-context-handler.ts

@@ -0,0 +1,9 @@
+import { HttpContext, HttpContextToken } from '@angular/common/http';
+
+export const CUSTOM_URL = new HttpContextToken<string>(()=> '');
+
+export class HttpContextHandler {
+  static setCustomUrl(url: string) {
+    return new HttpContext().set(CUSTOM_URL, url);
+  }
+}

package/src/lib/core/services/base-http-service/index.ts

@@ -0,0 +1,4 @@
+export * from './base-http-response';
+export * from './base-http-types';
+export * from './base-http-utils';
+export * from './base-http.service';

package/src/lib/core/services/base-pagination-service/base-pagination.service.ts

@@ -0,0 +1,59 @@
+import { Observable } from "rxjs";
+import { ListOptions } from "./list-options.interface";
+import { PAGE_SIZE_OPTION, PAGESIZE, SortDirection } from "./pagination";
+import { PaginatorState } from "primeng/paginator";
+export abstract class BasePaginationService<T = any> {
+
+  totalRecords = 0;
+  totalPages = 0;
+  rowsChange: number = PAGESIZE;
+
+  pageSizes = PAGE_SIZE_OPTION
+  defaultSortValue = "createdAt";
+  defaultSortDirection = SortDirection.DESC;
+  first: number | undefined = 0;
+
+  listOptions: ListOptions = {
+    searchValue: "",
+    paginator: this.rowsChange,
+    page: 0,
+    direction: this.defaultSortDirection,
+    sortBy: this.defaultSortValue
+  };
+
+  abstract getList(listOptions: ListOptions): void | Observable<T>
+
+  createListFilter(filters: {[key: string] : unknown}): void {
+    this.listOptions = {
+      ...this.listOptions,
+      ...filters
+    }
+  }
+
+  resetList(): void {
+    this.listOptions = {
+      searchValue: "",
+      paginator: this.rowsChange,
+      page: 0
+    };
+  }
+
+  resetPaginator(): void {
+    this.listOptions = {
+      ...this.listOptions ,
+      paginator: this.rowsChange,
+      page: 0
+    };
+  }
+
+  onPageChange(event: PaginatorState): void {
+    this.listOptions = {
+      ...this.listOptions,
+      page: event.page,
+      paginator: event.rows,
+    };
+    this.first = event.first ?? 0;
+    this.getList(this.listOptions);
+  }
+
+}

package/src/lib/core/services/base-pagination-service/index.ts

@@ -0,0 +1,3 @@
+export * from "./base-pagination.service";
+export * from "./list-options.interface";
+export * from "./pagination";

package/src/lib/core/services/base-pagination-service/list-options.interface.ts

@@ -0,0 +1,8 @@
+export interface ListOptions {
+  paginator?: number;
+  page?: number;
+  searchValue?: string;
+  direction?: "ASC" | "DESC";
+  sortBy?: string | null;
+  [key: string]: unknown;
+}

package/src/lib/core/services/base-pagination-service/pagination.ts

@@ -0,0 +1,6 @@
+export const PAGESIZE = 10;
+export const PAGE_SIZE_OPTION = [5, 10, 15, 20];
+export enum SortDirection {
+    ASC = 'ASC',
+    DESC = 'DESC'
+}

package/src/lib/core/services/enviroment.base.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+
+export interface EnvironmentConfig {
+  baseUrl: string;
+}
+
+@Injectable({
+  providedIn: 'root', // Ensures the service is provided at the root level
+})
+export class EnvironmentService {
+  constructor(private config: EnvironmentConfig) {}
+
+  getApiUrl() {
+    return this.config.baseUrl;
+  }
+}

package/src/lib/core/services/error-handler.service.ts

@@ -0,0 +1,74 @@
+import { HttpErrorResponse } from "@angular/common/http";
+import { ErrorHandler, Injectable } from "@angular/core";
+import { ToasterService } from "./toaster.service";
+import { TranslateService } from "@ngx-translate/core";
+import { from } from "rxjs";
+
+@Injectable({
+  providedIn: "root"
+})
+export class ErrorHandlerService implements ErrorHandler {
+  constructor(
+    private toasterService: ToasterService,
+    private translateService: TranslateService
+  ) { }
+
+  handleError(error: unknown) {
+
+    // check if there is an error in code
+    if (error instanceof Error) {
+      // this is commented because in code error we don't need to show the error to the user
+      // we can just log it for our reference
+      console.error(error);
+    }
+
+    if (error instanceof HttpErrorResponse) {
+      /**
+       * error handling here cause the error response is blob file (binary file)
+       * not JSON, so we can't parse it
+       * and need to check the content type of the response
+       **/
+      if (error?.error?.type === "application/json") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        from((error?.error as any).text()).subscribe((res) => {
+          const errorObj = JSON.parse(res as string);
+          const errorMessage = this.translateService.instant(`network_errors.${errorObj.errors.errorCode}`);
+          this.toasterService.showError({ summary: this.translateService.instant(`error`), detail: errorMessage });
+        });
+        return;
+      }
+      const errorInfo = error.error;
+      const errorCode = errorInfo.errors.message;
+      let errorMessage = errorInfo?.error;
+
+      if (errorInfo.code) {
+        switch (errorInfo.code) {
+          case 401:
+            break;
+          case 403:
+            break;
+          case 400:
+            errorMessage = this.translateService.instant(`network_errors.${errorCode}`);
+
+            break;
+          case 404:
+            if (errorCode) {
+              errorMessage = this.translateService.instant(`network_errors.${errorCode}`);
+              break;
+            }
+            errorMessage = this.translateService.instant(`validation_error.not_found`);
+            break;
+          case 500:
+          case 503:
+            errorMessage = this.translateService.instant(`validation_error.server`);
+            break;
+          default:
+            errorMessage = this.translateService.instant(`validation_error.random`);
+            break;
+        }
+
+        this.toasterService.showError({ summary: this.translateService.instant(`error`), detail: errorMessage });
+      }
+    }
+  }
+}

package/src/lib/core/services/index.ts

@@ -0,0 +1,8 @@
+export * from './jwt-decoder.service';
+export * from './lov.service';
+export * from './base-http-service';
+export * from './error-handler.service';
+export * from './toaster.service';
+export * from './permissions.service';
+export * from './auth.service';
+export * from './loader.service';

package/src/lib/core/services/jwt-decoder.service.ts

@@ -0,0 +1,23 @@
+import { inject, Injectable } from "@angular/core";
+import { jwtDecode } from "jwt-decode";
+import { AuthService } from "./auth.service";
+import { JWTDecoded } from "../interfaces/jwt-token-decoded.interface";
+
+@Injectable({
+  providedIn: "root"
+})
+export class JwtDecoderService {
+  authService = inject(AuthService);
+  public decodedToken: JWTDecoded;
+
+  constructor() {
+    this.decodeToken();
+  }
+
+  public decodeToken() {
+    const token: string = this.authService.getUserToken() as string;
+    if (token) {
+      this.decodedToken = jwtDecode(token);
+    }
+  }
+}

package/src/lib/core/services/loader.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+export interface LoaderState {
+  show: boolean;
+  isSystemLoader?: boolean;
+}
+
+@Injectable({
+  providedIn: "root"
+})
+export class LoaderService {
+  isLoading$ = new BehaviorSubject<LoaderState>({ show: false });
+  private loadingMap: Map<string, boolean> = new Map<string, boolean>();
+
+  setLoading(loading: boolean, isSystemLoader = true, url: string): void {
+    if (!url) {
+      throw new Error("The request URL must be provided to the LoaderService.setLoading function");
+    }
+
+    if (loading) {
+      this.loadingMap.set(url, loading);
+      this.isLoading$.next({ show: true, isSystemLoader });
+    } else if (!loading && this.loadingMap.has(url)) {
+      this.loadingMap.delete(url);
+    }
+
+    if (!this.loadingMap.size) {
+      this.isLoading$.next({ show: false });
+    }
+  }
+}

package/src/lib/core/services/lov.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { APP_HTTP_CONFIG } from '../interceptors';
+import { BaseHttpService, HttpConfig } from './base-http-service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ListOfValues extends BaseHttpService {
+  override setApiConfig(): HttpConfig {
+    return {
+      microServiceUrl: APP_HTTP_CONFIG.LOV_BASE_URL,
+      apiUrl: "lookups"
+    };
+  }
+
+  getRolesByGroup<T>(group: string): Observable<T> {
+    return this.getAll<T>({
+      urlPostfix: group
+    });
+  }
+}

package/src/lib/core/services/permissions.service.ts

@@ -0,0 +1,66 @@
+import { Injectable, inject } from "@angular/core";
+import { JwtDecoderService } from "./jwt-decoder.service";
+import { PermissionsActions, UserPermissionsEnum } from "../enums";
+import {BehaviorSubject} from "rxjs";
+
+@Injectable({
+  providedIn: "root"
+})
+export class PermissionsService {
+  private jwtDecoderService = inject(JwtDecoderService);
+  private decodedToken = this.jwtDecoderService.decodedToken;
+  private tokenPermissions = this.decodedToken ? this.decodedToken.permissions as [] : [];
+  private domainPermissionsSubject = new BehaviorSubject<string[]>([]);
+  domainPermissions$ = this.domainPermissionsSubject.asObservable();
+
+  private getKeyName(action: string) {
+    const actionsArr = action.split("_");
+    return actionsArr.splice(1, actionsArr.length - 1).join("_");
+  }
+
+  getActionName(action: string) {
+    return action.split("_")[0];
+  }
+
+  getAllowedActionsByKey(key: UserPermissionsEnum, newPermissions?: string[]) {
+    const permissionsNeeded = newPermissions || this.tokenPermissions;
+    if (!permissionsNeeded) {
+      console.error("There are no permissions available");
+      return [];
+    }
+    return permissionsNeeded
+      .filter((p) => {
+        return key === this.getKeyName(p);
+      })
+      .map((t) => {
+        return this.getActionName(t);
+      });
+  }
+
+  checkKeyHasPermission(key: UserPermissionsEnum, action: PermissionsActions, newPermissions?: string[]) {
+    return this.getAllowedActionsByKey(key, newPermissions).some((p) => p === action);
+  }
+
+  checkDomainHasPermission(key: UserPermissionsEnum, action: PermissionsActions) {
+    return this.getAllowedActionsByKey(key, this.getDomainPermissions()).some((p) => p === action);
+  }
+
+  routeGuardChecker(key: UserPermissionsEnum, action: PermissionsActions) {
+   if(!this.checkKeyHasPermission(key, action)){
+      return this.checkKeyHasPermission(key, action,this.getDomainPermissions());
+    }
+    return true;
+  }
+
+  clearDomainPermissions() {
+    this.domainPermissionsSubject.next([]);
+  }
+
+  setDomainPermissions(permissions: string[]) {
+    this.domainPermissionsSubject.next(permissions);
+  }
+
+  getDomainPermissions(): string[] {
+    return this.domainPermissionsSubject.getValue();
+  }
+}

package/src/lib/core/services/toaster.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from "@angular/core";
+import { MessageService, ToastMessageOptions } from "primeng/api";
+
+@Injectable({
+  providedIn: "root"
+})
+export class ToasterService {
+  mainKey = "main-toaster";
+
+  constructor(private messageService: MessageService) {}
+
+  showMessage(options: ToastMessageOptions) {
+    this.messageService.add({
+      key: options?.key ? options?.key : this.mainKey,
+      severity: options?.severity,
+      summary: options?.summary,
+      detail: options?.detail,
+      life: options?.life ?? 5000
+    });
+  }
+
+  showSuccess(options: ToastMessageOptions) {
+    this.messageService.add({
+      key: this.mainKey,
+      severity: "success",
+      summary: options?.summary,
+      detail: options?.detail,
+      life: options?.life ?? 5000
+    });
+  }
+
+  showError(options: ToastMessageOptions) {
+    this.messageService.add({
+      key: this.mainKey,
+      severity: "error",
+      summary: options?.summary,
+      detail: options?.detail,
+      life: options?.life ?? 5000
+    });
+  }
+
+  showInfo(options: ToastMessageOptions) {
+    this.messageService.add({
+      key: this.mainKey,
+      severity: "info",
+      summary: options?.summary,
+      detail: options?.detail,
+      life: options?.life ?? 5000
+    });
+  }
+
+  showWarning(key: string, summary: string, detail: string, life = 5000) {
+    this.messageService.add({
+      key: this.mainKey,
+      severity: "warn",
+      summary,
+      detail,
+      life
+    });
+  }
+
+  clear() {
+    this.messageService.clear(this.mainKey);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "extends": "../../tsconfig.base.json",
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true,
+    "exclude": ["**/*.spec.ts"]
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": ["src/**/*.spec.ts", "jest.config.ts", "src/**/*.test.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}