http-request-manager 18.7.21 → 18.7.24

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

@@ -1,65 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,24 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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());
-      })
-    );
-  }
-
-}