http-request-manager 18.7.19 → 18.7.21

package/src/lib/interceptors/request-error.interceptor.ts

@@ -0,0 +1,65 @@
+import { inject, Injectable } from '@angular/core'
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpErrorResponse } from '@angular/common/http'
+import { Observable, catchError, throwError } from 'rxjs'
+
+import { ToastMessageDisplayService, ToastDisplay, ToastColors } from 'toast-message-display'
+
+@Injectable()
+export class RequestErrorInterceptor implements HttpInterceptor {
+
+  toastMessage = inject(ToastMessageDisplayService)
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+
+    return next.handle(req).pipe(
+
+      catchError((error: HttpErrorResponse) => {
+
+        const displayError = ToastDisplay.adapt({
+          message: 'This is a toast message. This is an Error!!',
+          action: 'OK',
+          color: ToastColors.SUCCESS,
+          icon: 'info',
+          duration: 5 * 1000, //5 seconds
+        })
+
+        if (error.status >= 400 && error.status < 500) {
+
+          displayError.color = ToastColors.WARN
+          displayError.message = error.error || `${error.status}: ${error.statusText}`
+
+          console.error('Client Error:', {
+            status: error.status,
+            message: error.message,
+            error: error.error,
+            text: error.statusText,
+          })
+
+          this.toastMessage.toastMessage(displayError)
+
+        } else if (error.status >= 500) {
+
+          displayError.color = ToastColors.ERROR
+          displayError.message = error.error || `${error.status}: ${error.statusText}`
+
+          console.error('Server Error:', {
+            status: error.status,
+            message: error.message,
+            error: error.error,
+            text: error.statusText,
+          })
+
+          this.toastMessage.toastMessage(displayError)
+
+        }
+
+        return throwError(() => error)
+
+      })
+
+    )
+  }
+
+}
+
+

package/src/lib/interceptors/request-header.interceptor.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
+import { Observable, Subscription } from 'rxjs';
+import { LangChangeEvent, TranslateService } from '@ngx-translate/core';
+
+@Injectable()
+export class RequestHeadersInterceptor implements HttpInterceptor {
+
+  subscriptions = new Subscription()
+  language = 'en-CA'
+
+  get currentDate() {
+
+    const date = new Date()
+
+    const year = date.getFullYear()
+    const month = String(date.getMonth() + 1).padStart(2, '0')
+    const day = String(date.getDate()).padStart(2, '0')
+
+    return `${year}-${month}-${day}`
+
+  }
+
+  constructor(
+    private translate: TranslateService
+  ) {
+    this.subscriptions.add(
+      this.translate.onLangChange
+      .subscribe((params: LangChangeEvent) => {
+          this.language = `${params.lang}-CA`
+      })
+    )
+  }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+
+    request = request.clone({
+      setHeaders: {
+        'Content-Type': 'application/json',
+        'Accept-Language': this.language || 'en-CA',
+        'Current-Date': this.currentDate
+      }
+    })
+
+    return next.handle(request)
+
+  }
+
+  ngOnDestroy() {
+    this.subscriptions.unsubscribe()
+  }
+}
+

package/src/lib/models/config-http-options.model.ts

@@ -0,0 +1,42 @@
+import { RetryOptions } from "./retry-options.model"
+
+export interface ConfigHTTPOptionsInterface {
+  server: string
+  path?: any[]
+  headers?: any
+  polling?: number // seconds (undefined | 0 = none)
+  retry?: RetryOptions
+  stream?: boolean
+  displayError?: boolean
+}
+
+export class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
+
+  constructor(
+    public server = '',
+    public path?: any[],
+    public headers?: any,
+    public polling?: number,
+    public retry?: RetryOptions,
+    public stream?: boolean,
+    public displayError?: boolean,
+  ) {}
+
+  static adapt(item?: any): ConfigHTTPOptions {
+
+    const server = Array.isArray(item?.server) ? item.server.join('/') : item?.server || '';
+    const retryOptions = item?.retry ? RetryOptions.adapt(item.retry) : RetryOptions.adapt();
+
+    return new ConfigHTTPOptions(
+      server,
+      (item?.path) ? item.path : [],
+      (item?.headers) ? item.headers : {},
+      item?.polling ? Math.floor(item.polling) : 0,
+      retryOptions,
+      (item?.stream) ? item.stream : false,
+      (item?.displayError) ? item.displayError : false,
+    )
+
+  }
+
+}

package/src/lib/models/config-local-storage-options.model.ts

@@ -0,0 +1,27 @@
+import { SettingOptions } from "../services"
+
+export interface LocalStorageOptionsInterface {
+  storageName?: string
+  storageSettingsName?: string
+  options?: SettingOptions,
+}
+
+export class LocalStorageOptions implements LocalStorageOptionsInterface {
+
+  constructor(
+    public storageName?: string,
+    public storageSettingsName?: string,
+    public options?: SettingOptions,
+  ) {}
+
+  static adapt(item?: any): LocalStorageOptions {
+
+    return new LocalStorageOptions(
+      (item?.storageName) ? item.storageName : 'storage',
+      (item?.storageSettingsName) ? item.storageSettingsName : 'global-storage',
+      (item?.options) ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
+    )
+
+  }
+
+}

package/src/lib/models/config-options.model.ts

@@ -0,0 +1,27 @@
+import { ConfigHTTPOptions } from "./config-http-options.model";
+import { LocalStorageOptions } from "./config-local-storage-options.model";
+
+export interface ConfigOptionsInterface {
+  httpRequestOptions?: ConfigHTTPOptions
+  LocalStorageOptions?: LocalStorageOptions
+  // DatabaseOptions: any
+}
+
+export class ConfigOptions implements ConfigOptionsInterface {
+
+  constructor(
+    public httpRequestOptions?: ConfigHTTPOptions,
+    public LocalStorageOptions?: LocalStorageOptions,
+    // public DatabaseOptions?: any,
+  ) {}
+
+  static adapt(item?: any): ConfigOptions {
+    return new ConfigOptions(
+      (item?.httpRequestOptions) ? ConfigHTTPOptions.adapt(item.httpRequestOptions) : undefined,
+      (item?.LocalStorageOptions) ? LocalStorageOptions.adapt(item.LocalStorageOptions) : undefined,
+      // item?.DatabaseOptions,
+    )
+
+  }
+
+}

package/src/lib/models/config-token.model.ts

@@ -0,0 +1,9 @@
+import { InjectionToken } from "@angular/core";
+import { ConfigOptions } from "./config-options.model";
+
+/**
+ * An injection token that provides the configuration settings for the application.
+ * This token can be used to inject the `ConfigSettings` instance into components or services
+ * that require access to the application configuration.
+ */
+export const CONFIG_SETTINGS_TOKEN = new InjectionToken<ConfigOptions>('http.config');

package/src/lib/models/data-type.enum.ts

@@ -0,0 +1,5 @@
+export enum DataType {
+  ANY = 0,
+  ARRAY,
+  OBJECT
+}

package/src/lib/models/database-storage.model.ts

@@ -0,0 +1,24 @@
+export interface DatabaseStorageInterface {
+  table: string
+  expiresIn: string
+}
+
+export class DatabaseStorage implements DatabaseStorageInterface {
+
+  constructor(
+    public table = '',
+    public expiresIn: '',
+  ) {}
+
+  static adapt(item?: any): any {
+
+    if(!item?.table) return
+
+    return new DatabaseStorage(
+      item?.table,
+      item?.expiresIn,
+    )
+
+  }
+
+}

package/src/lib/models/index.ts

@@ -0,0 +1,12 @@
+export * from './database-storage.model'
+export * from './retry-options.model'
+
+export * from './data-type.enum'
+
+export * from './config-token.model'
+export * from './config-http-options.model'
+export * from './config-local-storage-options.model'
+export * from './config-options.model'
+
+export * from '../http-request-services-demo/request-manager-ws-demo/models/user-data.model'
+

package/src/lib/models/retry-options.model.ts

@@ -0,0 +1,22 @@
+export interface RetryOptionsInterface {
+  times?: number // total request to be made including initial request
+  delay?: number // seconds (<= 3 default 3 seconds)
+}
+
+export class RetryOptions implements RetryOptionsInterface {
+
+  constructor(
+    public times = 0,
+    public delay = 3,
+  ) {}
+
+  static adapt(item?: any): RetryOptions {
+
+    return new RetryOptions(
+      item?.times,
+      item?.delay
+    )
+
+  }
+
+}

package/src/lib/services/database-manager-service/database.manager.service.ts

@@ -0,0 +1,262 @@
+import { Injectable } from '@angular/core';
+import { DbService } from './db.storage.service';
+
+import { TableSchemaDef } from './models/table-schema';
+import { EMPTY, from, Observable } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DatabaseManagerService extends DbService {
+
+  constructor() {
+    super()
+  }
+
+  getDatabaseTables() {
+    return from(this.DBOpened()).pipe(
+      map(() => this.tables.map((item: any) => item.name))
+    )
+  }
+
+  databaseExists(): Observable<boolean> {
+    return from(this.hasDatabase());
+  }
+
+  hasDatabaseTable(table: string): Observable<boolean> {
+    const tableName = this.cleanTableName(table);
+    return from(this.DBOpened()).pipe(
+      map(() => {
+        return this.tableExists(tableName)
+      })
+    )
+  }
+
+  getDatabaseTable(table: string): Observable<any> {
+    const tableName = this.cleanTableName(table);
+    return from(this.DBOpened()).pipe(
+      map(() => {
+          const found = this.getTable(tableName);
+          if(!found) {
+            console.warn('No Such Table:', tableName)
+            return null;
+          }
+          return found;
+      })
+    )
+  }
+
+  getDatabaseTableSchema(table: string): Observable<string[]> {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+      map((dbTable: any) => {
+        if(!dbTable) return []
+        const cols = dbTable.schema.indexes.map((col: any) => col.name)
+        const pri = dbTable.schema.primKey.name
+        return [pri, ...cols]
+      })
+    )
+  }
+
+  createDatabaseTable(tableDef: TableSchemaDef) {
+    return from(this.createTable(tableDef.table, tableDef.schema)).pipe(
+      switchMap(() => this.DBOpened())
+    )
+  }
+
+  updateDatabaseTableSchema(tableDef: TableSchemaDef) {
+    return from(this.createTable(tableDef.table, tableDef.schema)).pipe(
+      switchMap(() => this.getDatabaseTable(tableDef.table))
+    )
+  }
+
+  // CRUD
+  findTableRecords(table: string, column: string, value: any) {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+      switchMap((tableData: any) => {
+        if (!tableData) {
+          console.warn(`findTableRecords: Table '${tableName}' not found`);
+          return from([]);
+        }
+        return from(tableData.where(column).equals(value).toArray());
+      })
+    );
+  }
+
+  findTableRecord(table: string, column: string, value: any) {
+    const tableName = this.cleanTableName(table);
+    return this.findTableRecords(tableName, column, value).pipe(
+      map((records: any) => records && records.length > 0 ? records[0] : null)
+    );
+  }
+
+  getTableRecords(table: string) {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+      switchMap((tableData: any) => {
+        if (!tableData) {
+          console.warn(`getTableRecords: Table '${tableName}' not found`);
+          return from([]);
+        }
+        return from(tableData.toArray());
+      })
+    );
+  }
+
+  getTableRecord(table: string, id: number) {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+      switchMap((tableData: any) => {
+        if (!tableData) {
+          console.warn(`getTableRecord: Table '${tableName}' not found`);
+          return from([null]);
+        }
+        return from(tableData.get(id)).pipe(
+          map((record: any) => record || null)
+        );
+      })
+    );
+  }
+
+  createTableRecord(table: string, record: any) {
+    const tableName = this.cleanTableName(table);
+    return this.createTableRecords(tableName, [record])
+    .pipe(
+      map((item: any) => item ? item[0] : null))
+  }
+
+  createTableRecords(table: string, records: any[]) {
+    const tableName = this.cleanTableName(table);
+    return from(this.DBOpened()).pipe(
+      switchMap(() => {
+        if (!this.tables.some(t => t.name === tableName)) {
+             console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
+             return EMPTY;
+        }
+
+        const tableInstance = this.table(tableName);
+
+        // Extract schema fields directly from the table instance
+        const schema = tableInstance.schema;
+        const validFields = [
+            schema.primKey.name,
+            ...schema.indexes.map(idx => idx.name)
+        ];
+
+        const insertRecords = records.map((record: any) => {
+            const objectFromSchema: { [key: string]: any } = {};
+            validFields.forEach((field: string) => {
+                if (field) {
+                    objectFromSchema[field] = (record as any)[field] ?? null;
+                }
+            });
+            return objectFromSchema;
+        });
+
+        console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
+
+        return from(tableInstance.bulkPut(insertRecords)).pipe(
+            map(() => insertRecords)
+        );
+      })
+    );
+  }
+
+  updateTableRecord(table: string, record: any) {
+    const tableName = this.cleanTableName(table);
+    return this.updateTableRecords(tableName, [record])
+    .pipe(
+      map(item => item.length > 0 ? item[0] : null)
+    )
+  }
+
+  updateTableRecords(table: string, records: any[]) {
+
+    const tableName = this.cleanTableName(table);
+
+    return this.getDatabaseTable(tableName).pipe(
+
+      switchMap((tableData: any) => {
+
+        return this.getDatabaseTableSchema(tableName).pipe(
+
+          switchMap((schema: string[]) => {
+
+            const insertRecords = records.map((record: any) => {
+
+              const objectFromSchema: { [key: string]: any } = {}
+
+              schema.forEach((field: string) => {
+                const data = (record as any)[field] ?? null
+                objectFromSchema[field] = data
+              })
+
+              return objectFromSchema
+
+            })
+
+            return from(tableData.bulkPut(insertRecords)).pipe(
+                map(() => insertRecords)
+            );
+
+          })
+
+        )
+
+      })
+
+    )
+
+  }
+
+  deleteTableRecord<T>(table: string, id: number) {
+    const tableName = this.cleanTableName(table);
+    return this.deleteTableRecords(tableName, [id])
+    .pipe(
+      map(item => item.length > 0 ? item[0] : null)
+    )
+  }
+
+  deleteTableRecords(table: string, ids: number[]) {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+
+      switchMap((tableData: any) => {
+
+        return this.getDatabaseTableSchema(tableName).pipe(
+
+          switchMap((schema: string[]) => {
+
+            console.log(`deleteTableRecords: Starting delete of ${ids.length} records from ${table}. IDs:`, ids);
+
+            return from(tableData.bulkDelete(ids)).pipe(
+                map(() => ids)
+            );
+
+          })
+
+        )
+
+      })
+
+    )
+
+  }
+
+  clearTable(table: string) {
+    const tableName = this.cleanTableName(table);
+    return this.getDatabaseTable(tableName).pipe(
+      switchMap((tableData: any) => {
+        if (!tableData) {
+          console.warn(`clearTable: Table '${tableName}' not found`);
+          return from([]);
+        }
+        console.log(`clearTable: Clearing all records from ${tableName}`);
+        return from(tableData.clear());
+      })
+    );
+  }
+
+}