@corp-products/app-core 0.0.1

package/src/lib/core/directives/permissions.directive.ts

@@ -0,0 +1,114 @@
+import {
+  Directive,
+  Input,
+  OnDestroy,
+  OnInit,
+  TemplateRef,
+  ViewContainerRef,
+} from '@angular/core';
+import { PermissionsService } from '../services';
+import { PermissionsActions, UserPermissionsEnum } from '../enums';
+import { Subscription } from 'rxjs';
+
+@Directive({
+  selector: '[hasPermissions]',
+  standalone: true
+})
+export class HasPermissionsDirective implements OnInit, OnDestroy {
+  private _actions: string[];
+  private _key: string;
+  private _newPermissions: string[];
+  private _isDomain: boolean;
+
+  private isViewCreated = false;
+  private subscription: Subscription;
+
+  constructor(
+    private permissionsService: PermissionsService,
+    private viewContainer: ViewContainerRef,
+    private templateRef: TemplateRef<unknown>
+  ) {}
+
+  /**
+   *  make sure that the key value looks like the UserPermissionsEnum enum
+   *  usage: *permissions="[PermissionsActions.EDIT]; key: LOOKUPS
+   */
+
+  @Input({ required: true }) set hasPermissions(actions: string[]) {
+    if (this.arraysChanged(this._actions, actions)) {
+      this._actions = actions;
+      this.updateView();
+    }
+  }
+
+  @Input({ required: true }) set hasPermissionsKey(key: string) {
+    if (this._key !== key) {
+      this._key = key;
+      this.updateView();
+    }
+  }
+
+  @Input() set hasPermissionsNewPermissions(newPermissions: string[]) {
+    if (this.arraysChanged(this._newPermissions, newPermissions)) {
+      this._newPermissions = newPermissions;
+      this.updateView();
+    }
+  }
+
+  @Input() set hasPermissionsIsDomain(isDomain: boolean) {
+    if (this._isDomain !== isDomain) {
+      this._isDomain = isDomain;
+      this.updateView();
+    }
+  }
+
+  ngOnInit(): void {
+    this.subscription = this.permissionsService.domainPermissions$.subscribe(() => {
+      if (this._isDomain) {
+        this.updateView();
+      }
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.subscription?.unsubscribe();
+  }
+
+  private updateView() {
+    const canShow = this._actions.some(action => this.hasPermission(action));
+
+    if (canShow && !this.isViewCreated) {
+      this.viewContainer.createEmbeddedView(this.templateRef);
+      this.isViewCreated = true;
+    } else if (!canShow && this.isViewCreated) {
+      this.clearView();
+    }
+  }
+
+  private hasPermission(action: string): boolean {
+    if (this._isDomain) {
+      return this.permissionsService.checkDomainHasPermission(
+        this._key as UserPermissionsEnum,
+        action as PermissionsActions
+      );
+    }
+
+    return this.permissionsService.checkKeyHasPermission(
+      this._key as UserPermissionsEnum,
+      action as PermissionsActions,
+      this._newPermissions
+    );
+  }
+
+  private clearView() {
+    this.viewContainer.clear();
+    this.isViewCreated = false;
+  }
+
+  private arraysChanged(a?: string[], b?: string[]): boolean {
+    if (a === b) return false;
+    if (!a || !b) return true;
+    if (a.length !== b.length) return true;
+    return a.some((v, i) => v !== b[i]);
+  }
+}

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

@@ -0,0 +1 @@
+export * from './user-permissions.enum';

package/src/lib/core/enums/user-permissions.enum.ts

@@ -0,0 +1,36 @@
+export enum UserPermissionsEnum {
+  BOD = "BOD",
+  BOARD_COMMITTEES = "BOARD_COMMITTEES",
+  BOARD_MEETINGS = "BOARD_MEETINGS",
+  MEETING_INSIDE_THE_BOD = "MEETING_INSIDE_THE_BOD",
+  COMMITTEE = "COMMITTEE",
+  MEETING_INSIDE_THE_COMMITTEE = "MEETING_INSIDE_THE_COMMITTEE",
+  MEETING = "MEETING",
+  DECISION = "DECISION",
+  RECOMMENDATION = "RECOMMENDATION",
+  TASK = "TASK",
+  VOTING = "VOTING",
+  VOTING_SECRETARY_RESULTS = "VOTING_SECRETARY_RESULTS",
+  VOTING_RESULTS = "VOTING_RESULTS",
+  DRAFT_MOM = "DRAFT_MOM",
+  FINAL_MOM = "FINAL_MOM",
+  MOM = "MOM",
+  AGENDA = "AGENDA",
+  ATTENDEES = "ATTENDEES",
+  COMMENT = "COMMENT"
+}
+
+export enum PermissionsActions {
+  VIEW = "VIEW",
+  CREATE = "CREATE",
+  EDIT = "EDIT",
+  DELETE = "DELETE",
+  REORDER = "REORDER",
+  DOWNLOAD = "DOWNLOAD",
+  MARK = "MARK",
+  GENERATE = "GENERATE",
+  TERMINATE = "TERMINATE",
+  START = "START",
+  END = "END",
+  ACTIVATE = "ACTIVATE"
+}

package/src/lib/core/guards/auth.guard.ts

@@ -0,0 +1,17 @@
+import { inject } from "@angular/core";
+import { CanActivateFn } from "@angular/router";
+import { AuthService } from "../services";
+import { CORE_CONFIG, CoreConfig } from "../core-config";
+
+export const authGuard: CanActivateFn = () => {
+  const appConfig = inject<CoreConfig>(CORE_CONFIG);
+  const authService = inject(AuthService);
+  const token: string | null = authService.getUserToken();
+
+  if (!token) {
+    window.location.href = appConfig.loginUrl;
+    return false;
+  }
+
+  return true;
+};

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

@@ -0,0 +1,2 @@
+export * from './auth.guard';
+export * from './permissions.guard';

package/src/lib/core/guards/permissions.guard.ts

@@ -0,0 +1,17 @@
+import { inject } from "@angular/core";
+import { CanActivateFn, Router } from "@angular/router";
+import { PermissionsService } from "../services";
+import { RoutePermissionsInfo } from "../interfaces";
+
+export const permissionsGuard: CanActivateFn = (route) => {
+  const permissionsService = inject(PermissionsService);
+  const router = inject(Router);
+  const { key, action }: RoutePermissionsInfo = route.data["permissions"];
+
+  if (!route.data["permissions"] || (route.data["permissions"] && permissionsService.routeGuardChecker(key, action))) {
+    return true;
+  } else {
+    router.navigate(["no-access"]);
+    return false;
+  }
+};

package/src/lib/core/handlers/http-context-handler.ts

@@ -0,0 +1,9 @@
+import { HttpContext, HttpContextToken } from '@angular/common/http';
+
+export const IS_SYSTEM_LOADER = new HttpContextToken<boolean>(() => true); // set default loader
+
+export class HttpContextHandler {
+  static setLoaderType(isSystemLoader: boolean) {
+    return new HttpContext().set(IS_SYSTEM_LOADER, isSystemLoader);
+  }
+}

package/src/lib/core/handlers/storage-handler.ts

@@ -0,0 +1,37 @@
+// Important for global context
+import { LocalStorageKeys, SessionStorageKeys, StorageEnum } from "./stortage";
+
+const setLocalStorage = (key: string, value: string) => localStorage.setItem(key, value);
+const getLocalStorage = (key: string) => localStorage.getItem(key);
+const clearLocalStorage = () => localStorage.clear();
+const setSessionStorage = (key: string, value: string) => sessionStorage.setItem(key, value);
+const getSessionStorage = (key: string) => sessionStorage.getItem(key);
+const clearSessionStorage = () => sessionStorage.clear();
+
+export class StorageHandler {
+  public static local = {
+    set: (key: LocalStorageKeys, value: unknown) => this.setItem(key, value, setLocalStorage),
+    get: <T>(key: LocalStorageKeys) => this.getItem<T>(key, getLocalStorage),
+    clear: () => this.clearStorage(clearLocalStorage)
+  };
+  public static session = {
+    set: (key: SessionStorageKeys, value: unknown) => this.setItem(key, value, setSessionStorage),
+    get: <T>(key: SessionStorageKeys) => this.getItem<T>(key, getSessionStorage),
+    clear: () => this.clearStorage(clearSessionStorage)
+  };
+
+  private static setItem(key: StorageEnum, value: unknown, set: (key: string, value: string) => void): void {
+    if (!key) return;
+    set(key as string, typeof value === "string" ? value : JSON.stringify(value));
+  }
+
+  private static getItem<T>(key: StorageEnum, get: (key: string) => string | null, withParsing = false): T | null {
+    const data: string | null = get(key as string) ?? null;
+    if (data) return withParsing ? JSON.parse(data) : data;
+    return null;
+  }
+
+  private static clearStorage(clear: () => void): void {
+    clear();
+  }
+}

package/src/lib/core/handlers/stortage.ts

@@ -0,0 +1,7 @@
+export enum LocalStorageKeys {
+  LANGUAGE = "LANGUAGE",
+  TOKEN = "TOKEN"
+}
+
+export enum SessionStorageKeys {}
+export type StorageEnum = SessionStorageKeys | LocalStorageKeys;

package/src/lib/core/interceptors/app-http-config.ts

@@ -0,0 +1,8 @@
+export const COMMON_BASE_URL = "common/api/v1";
+export const APP_HTTP_CONFIG = {
+  BOARD_BASE_URL: "board-acl/private/v1",
+  MEETING_BASE_URL: "meeting-acl/private/v1",
+  IGATE_BASE_URL: COMMON_BASE_URL + "/igate-users",
+  LOV_BASE_URL: COMMON_BASE_URL + "/lov",
+  ATTACHMENT_BASE_URL: COMMON_BASE_URL + "/attachment"
+};

package/src/lib/core/interceptors/base-http.interceptor.ts

@@ -0,0 +1,44 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Inject, inject, Injectable } from "@angular/core";
+import { finalize, Observable, tap } from "rxjs";
+import { IS_SYSTEM_LOADER } from "../handlers/http-context-handler";
+import { AuthService } from "../services/auth.service";
+import { LoaderService } from "../services/loader.service";
+import { CORE_CONFIG, CoreConfig } from "../core-config";
+
+@Injectable()
+export class HttpBaseInterceptor implements HttpInterceptor {
+  authService = inject(AuthService);
+  loaderService = inject(LoaderService);
+
+  constructor(@Inject(CORE_CONFIG) protected appConfig: CoreConfig) {}
+
+  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
+    console.log("interceptor", this.appConfig);
+    const URL = `${this.appConfig.gatewayUrl}${request.url}`;
+    const token = this.authService.getUserToken();
+
+    // Handler header
+    request = request.clone({
+      url: URL,
+      setHeaders: {
+        Authorization: `Bearer ${token}`,
+        Language: "en"
+      }
+    });
+
+    // Handle loader
+    const IS_SYSTEM_LOADER_CHECK = request.context.get(IS_SYSTEM_LOADER);
+    this.loaderService.setLoading(true, IS_SYSTEM_LOADER_CHECK, request.url);
+
+    return next.handle(request).pipe(
+      // Handler Token
+      tap((event) => {
+        //  if (event instanceof HttpResponse && request.url.includes(User_Token)) {
+        // Set user token ..
+        //  }
+      }),
+      finalize(() => this.loaderService.setLoading(false, IS_SYSTEM_LOADER_CHECK, request.url))
+    );
+  }
+}

package/src/lib/core/interceptors/global-http-error.interceptor.ts

@@ -0,0 +1,21 @@
+import { HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable, retry, timer } from 'rxjs';
+
+export class GlobalHttpErrorInterceptor implements HttpInterceptor {
+  // check if it is a server error to retry the request
+  shouldRetry(error: HttpErrorResponse) {
+    if (error.status >= 500) {
+      return timer(1000);
+    }
+    throw error;
+  }
+
+  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
+    return next.handle(request).pipe(
+      retry({
+        count: 1,
+        delay: this.shouldRetry
+      })
+    );
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from "./app-http-config";
+export * from "./base-http.interceptor";
+export * from "./global-http-error.interceptor";

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

@@ -0,0 +1,3 @@
+export * from "./router-data.interface"
+export * from "./list-response.interface"
+export * from "./user-info.interface"

package/src/lib/core/interfaces/jwt-token-decoded.interface.ts

@@ -0,0 +1,7 @@
+import { JwtPayload } from "jwt-decode";
+import { UserProfileData } from "./user-profile-data";
+export interface JWTDecoded extends JwtPayload {
+  permissions: string[];
+  role: string;
+  profile: UserProfileData;
+}

package/src/lib/core/interfaces/list-response.interface.ts

@@ -0,0 +1,5 @@
+export interface ListResponse<T> {
+  data: T;
+  totalElements: number;
+  totalPages: number;
+}

package/src/lib/core/interfaces/router-data.interface.ts

@@ -0,0 +1,20 @@
+import { Route } from "@angular/router";
+import {PermissionsActions, UserPermissionsEnum} from "../enums";
+
+export interface RouteData {
+  breadcrumb?: ((data: RouteData) => string) | string;
+  showBreadcrumb?: boolean;
+  isClickableInBreadcrumb?: boolean;
+  permissions?: RoutePermissionsInfo;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+export interface RoutePermissionsInfo {
+  key: UserPermissionsEnum;
+  action: PermissionsActions;
+}
+export interface AppRoute extends Route {
+  data?: RouteData;
+  children?: AppRoute[];
+}

package/src/lib/core/interfaces/user-info.interface.ts

@@ -0,0 +1,4 @@
+export interface UserInfo {
+    userName:string;
+    email:string;
+}

package/src/lib/core/interfaces/user-profile-data.ts

@@ -0,0 +1,19 @@
+export interface UserProfileData {
+  contact: Contact;
+  position: Position;
+  email: string;
+  profileImage: string;
+  nameEn: string;
+  nameAr: string;
+}
+
+export interface Contact {
+  mobile: string;
+  work: string;
+}
+
+export interface Position {
+  code: string;
+  name: string;
+}
+

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

@@ -0,0 +1,63 @@
+import { Inject, Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { StorageHandler } from "../handlers/storage-handler";
+import { LocalStorageKeys } from "../handlers/stortage";
+import { BaseHttpService, HttpConfig } from "./base-http-service";
+import { CORE_CONFIG, CoreConfig } from "../core-config";
+
+@Injectable({
+  providedIn: "root"
+})
+export class AuthService extends BaseHttpService {
+  public isUserLoggedIn$ = new BehaviorSubject(this.isLoggedIn());
+
+  constructor(@Inject(CORE_CONFIG) protected appConfig: CoreConfig) {
+    super();
+  }
+
+  override setApiConfig(): HttpConfig {
+    return {
+      apiUrl: "",
+      microServiceUrl: ""
+    };
+  }
+
+  initAuthentication() {
+    const token: string | null = new URLSearchParams(window.location.search).get("token");
+    if (token) {
+      this.setAuthentication(token);
+      window.location.search = "";
+    }
+  }
+
+  setAuthentication(token: string) {
+    this.isUserLoggedIn$.next(true);
+    this.setUserToken(token);
+  }
+
+  isLoggedIn(): boolean {
+    return !!this.getUserToken();
+  }
+
+  getUserToken(): string | null {
+    return StorageHandler.local.get(LocalStorageKeys.TOKEN);
+  }
+
+  setUserToken(token?: string) {
+    return StorageHandler.local.set(LocalStorageKeys.TOKEN, token);
+  }
+
+  logoutFromSSO() {
+    const logoutUrl = this.appConfig.logoutEndpoint;
+    return this.single<unknown>("", {
+      urlRewrite: logoutUrl
+    });
+  }
+
+  clearAuth() {
+    StorageHandler.local.clear();
+    StorageHandler.session.clear();
+    this.isUserLoggedIn$.next(false);
+    window.location.href = this.appConfig.loginUrl;
+  }
+}

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

@@ -0,0 +1,14 @@
+export interface BaseHttpResponse<T> {
+  code: number;
+  errors: BaseError;
+  payload: T;
+  serviceTime: string;
+  success: boolean;
+}
+
+interface BaseError {
+  errorCode: string;
+  type: string;
+  timestamp: string;
+  param: string[];
+}

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

@@ -0,0 +1,42 @@
+import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Params as RouterParams } from '@angular/router';
+
+export interface HttpConfig {
+  apiUrl?: string;
+  microServiceUrl:string;
+  globalMapFn?: (res: any) => any;
+  methods?: ServiceConfig;
+}
+
+export type Params =
+  | HttpParams
+  | { [param: string]: string | string[] | unknown };
+export type HttpRequestOptions = {
+  headers?:
+    | HttpHeaders
+    | RouterParams
+    | { [header: string]: string | string[] };
+  params?: HttpParams | { [param: string]: string | string[] } | Params;
+  context?: HttpContext;
+  reportProgress?: boolean;
+  observe?: 'events';
+  responseType?: string;
+};
+export const HttpRequestOptionsKeys: Array<keyof Required<HttpRequestOptions>> =
+  ['headers', 'params', 'context', 'reportProgress', 'observe', 'responseType'];
+
+export type HttpOptions<T = any> = HttpRequestOptions & {
+  urlRewrite?: string;
+  urlPostfix?: string;
+  mapFn?: (res: any) => T;
+};
+
+export interface ServiceConfig {
+  single?: HttpOptions;
+  getAll?: HttpOptions;
+  add?: HttpOptions;
+  update?: HttpOptions;
+  delete?: HttpOptions;
+}
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

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

@@ -0,0 +1,48 @@
+import { map } from 'rxjs/operators';
+import { HttpOptions, HttpRequestOptionsKeys } from './base-http-types';
+import { BaseHttpResponse } from './base-http-response';
+
+export const resolveUrl = (
+  baseUrl: string,
+  options?: HttpOptions,
+  ...args: string[]
+): string => {
+  const { urlRewrite, urlPostfix } = options || {};
+
+  if (urlRewrite) {
+    return urlRewrite;
+  }
+
+  let result = baseUrl;
+
+  if (args && args.length > 0 && args[0] !== '') {
+    result += `/${args.join('/')}`;
+  }
+
+  if (urlPostfix) {
+    result += `/${urlPostfix}`;
+  }
+
+  return result;
+};
+
+export const extractRequestOptions = (options?: any) => {
+  if (!options || typeof options !== 'object') {
+    return {};
+  }
+  /* eslint-disable */
+  return HttpRequestOptionsKeys.reduce((requestOptions: any, key) => {
+    const value = options[key];
+
+    if (value !== undefined) {
+      requestOptions[key] = value;
+    }
+
+    return requestOptions;
+  }, {});
+};
+
+export const mapResponse = <T>(options?: HttpOptions) =>
+  map((res: T) => (options?.mapFn ? options.mapFn(res) : res));
+
+export const epmDefaultMapper = <T>(res: BaseHttpResponse<T>) => res.payload;

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

@@ -0,0 +1,106 @@
+import { HttpClient } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HttpConfig, HttpOptions, ServiceConfig } from './base-http-types';
+import { epmDefaultMapper, extractRequestOptions, mapResponse, resolveUrl } from './base-http-utils';
+
+export abstract class BaseHttpService {
+  private readonly http: HttpClient = inject(HttpClient);
+
+  get url(): string {
+    const { apiUrl,microServiceUrl } = this.setApiConfig();
+    return `${microServiceUrl}${apiUrl ? `/${apiUrl}` : ''}`;
+  }
+
+  get methodsConfig(): ServiceConfig | undefined {
+    const { methods } = this.setApiConfig();
+    return methods;
+  }
+
+  get globalMapFn(): (res: any) => any {
+    const { globalMapFn } = this.setApiConfig();
+    return globalMapFn || epmDefaultMapper;
+  }
+
+  abstract setApiConfig(): HttpConfig;
+
+  single<T>(id: string | number, options?: HttpOptions): Observable<T> {
+    const activeOptions = options || this.getMethodConfig('single');
+    const url = resolveUrl(this.url, activeOptions, id?.toString());
+    const requestOptions = extractRequestOptions(activeOptions);
+
+    return this.http
+      .get<T>(url, requestOptions)
+      .pipe(mapResponse(this.getMapFun(activeOptions)));
+  }
+
+  getAll<T>(options?: HttpOptions): Observable<T> {
+    const activeOptions = options || this.getMethodConfig('getAll');
+    const url = resolveUrl(this.url, activeOptions);
+    const requestOptions = extractRequestOptions(activeOptions);
+
+    return this.http
+      .get<T>(url, requestOptions)
+      .pipe(mapResponse(this.getMapFun(activeOptions)));
+  }
+
+  add<T>(body: unknown, options?: HttpOptions): Observable<T> {
+    const activeOptions = options || this.getMethodConfig('add');
+    const url = resolveUrl(this.url, activeOptions);
+    const requestOptions = { ...extractRequestOptions(activeOptions) };
+
+    return this.http
+      .post<T>(url, body, requestOptions)
+      .pipe(mapResponse(this.getMapFun(activeOptions)));
+  }
+
+  update<T>(
+    id: string | number,
+    body: unknown,
+    options?: HttpOptions
+  ): Observable<T> {
+    const activeOptions = options || this.getMethodConfig('update');
+    const url = resolveUrl(this.url, activeOptions, id?.toString());
+    const requestOptions = { ...extractRequestOptions(activeOptions) };
+
+    return this.http
+      .put<T>(url, body, requestOptions)
+      .pipe(mapResponse(this.getMapFun(activeOptions)));
+  }
+
+  delete<T>(id: string | number, options?: HttpOptions): Observable<T> {
+    const activeOptions = options || this.getMethodConfig('delete');
+    const url = resolveUrl(this.url, activeOptions, id?.toString());
+    const requestOptions = extractRequestOptions(activeOptions);
+
+    return this.http
+      .delete<T>(url, requestOptions)
+      .pipe(mapResponse(this.getMapFun(activeOptions)));
+  }
+
+  protected getMethodConfig(method: keyof ServiceConfig): any {
+    return this.methodsConfig ? this.methodsConfig[method] : undefined;
+  }
+
+  protected getMapFun(options?: HttpOptions) {
+    const getMapFunObj = {
+      default: { mapFn: epmDefaultMapper },
+      custom: { mapFn: this.globalMapFn },
+    };
+
+    if (
+      options &&
+      (options?.reportProgress || options?.responseType === 'blob')
+    ) {
+      return { mapFn: (res: unknown) => res };
+    }
+
+    if (options && options?.mapFn) {
+      return { mapFn: options.mapFn };
+    }
+
+    const isGlobalMapFnValid =
+      this.globalMapFn && typeof this.globalMapFn === 'function';
+    return isGlobalMapFnValid ? getMapFunObj.custom : getMapFunObj.default;
+  }
+}