http-request-manager 18.15.32 → 18.15.34

package/src/lib/message-display/models/display-rule.interface.ts

@@ -0,0 +1,28 @@
+import { DisplayConfig } from './display-config.model';
+import { CommunicationMessage } from './communication-message.model';
+
+export interface DisplayRuleInterface {
+  id: string;
+  name?: string;
+  match: (message: CommunicationMessage) => boolean;
+  display: DisplayConfig;
+}
+
+export class DisplayRule implements DisplayRuleInterface {
+  constructor(
+    public id: string = '',
+    public name?: string,
+    public match: (message: CommunicationMessage) => boolean = () => false,
+    public display: DisplayConfig = DisplayConfig.adapt(),
+  ) {}
+
+  static adapt(item?: any): DisplayRule {
+    return new DisplayRule(
+      item?.id,
+      item?.name,
+      item?.match,
+      item?.display ? DisplayConfig.adapt(item.display) : DisplayConfig.adapt(),
+    );
+  }
+}
+

package/src/lib/message-display/models/display-strategy.interface.ts

@@ -0,0 +1,8 @@
+import { CommunicationMessage } from '../models/communication-message.model';
+import { DisplayConfig } from '../models/display-config.model';
+
+export interface IDisplayStrategy {
+  name: string;
+  canHandle(message: CommunicationMessage): boolean;
+  display(message: CommunicationMessage, config: DisplayConfig): void;
+}

package/src/lib/message-display/models/index.ts

@@ -0,0 +1,6 @@
+export * from './display-config.model';
+export * from './display-rule.interface';
+export * from './display-strategy.interface';
+export * from './communication-message.model';
+export * from './slide.model';
+export * from './action.model';

package/src/lib/message-display/models/slide.model.ts

@@ -0,0 +1,24 @@
+export interface SlideInterface {
+  title: string;
+  message: string;
+  image?: string;
+  icon?: string;
+}
+
+export class Slide implements SlideInterface {
+  constructor(
+    public title: string = '',
+    public message: string = '',
+    public image?: string,
+    public icon?: string
+  ) {}
+
+  static adapt(item?: any): Slide {
+    return new Slide(
+      item?.title,
+      item?.message,
+      item?.image,
+      item?.icon
+    );
+  }
+}

package/src/lib/message-display/rules/default-display-rules.ts

@@ -0,0 +1,35 @@
+import { DisplayRule } from '../models/display-rule.interface';
+
+export const defaultDisplayRules: DisplayRule[] = [
+  {
+    id: 'carousel',
+    name: 'Carousel',
+    match: (message) => message.content?.displayConfig?.type === 'carousel',
+    display: {
+      type: 'carousel',
+      supportsMarkdown: true,
+      stackable: false
+    }
+  },
+  {
+    id: 'dialog',
+    name: 'Dialog',
+    match: (message) => message.content?.displayConfig?.type === 'dialog',
+    display: {
+      type: 'dialog',
+      supportsMarkdown: true,
+      stackable: true
+    }
+  },
+  {
+    id: 'default',
+    name: 'Snackbar',
+    match: () => true,
+    display: {
+      type: 'snackbar',
+      supportsMarkdown: false,
+      stackable: true,
+      autoDismiss: 3000
+    }
+  }
+];

package/src/lib/message-display/services/message-display-router.service.ts

@@ -0,0 +1,63 @@
+import { Injectable, inject } from '@angular/core';
+import { IDisplayStrategy } from '../models/display-strategy.interface';
+import { DisplayRule } from '../models/display-rule.interface';
+import { CommunicationMessage } from '../models/communication-message.model';
+import { defaultDisplayRules } from '../rules/default-display-rules';
+import { SnackbarStrategy } from '../strategies/snackbar.strategy';
+
+@Injectable({ providedIn: 'root' })
+export class MessageDisplayRouterService {
+
+  private snackbarStrategy = inject(SnackbarStrategy);
+
+  // All available strategies
+  private strategies: IDisplayStrategy[] = [
+    this.snackbarStrategy
+    // DialogStrategy will be added in Phase 2
+    // CarouselStrategy will be added in Phase 3
+  ];
+
+  // Rules are evaluated in order - first match wins
+  private rules: DisplayRule[] = defaultDisplayRules;
+
+  display(message: CommunicationMessage): void {
+    console.log('📨 MessageDisplayRouterService: Processing message:', message);
+
+    // Find FIRST matching rule (order matters!)
+    const matchingRule = this.rules.find(rule => rule.match(message));
+
+    // Get the rule (will be 'default' if nothing else matches)
+    const rule = matchingRule || this.rules[this.rules.length - 1];
+
+    console.log(`🎯 MessageDisplayRouterService: Matched rule '${rule.id}' (${rule.name})`);
+    console.log(`   → Display type: ${rule.display.type}`);
+
+    // Get strategy for the display type
+    const strategy = this.strategies.find(s => s.name === rule.display.type);
+
+    if (!strategy) {
+      console.warn(`⚠️ MessageDisplayRouterService: No strategy found for type '${rule.display.type}', falling back to snackbar`);
+      // Fallback to snackbar if strategy not found
+      this.snackbarStrategy.display(message, rule.display);
+      return;
+    }
+
+    // Execute display
+    console.log(`🚀 MessageDisplayRouterService: Executing ${strategy.name} strategy`);
+    strategy.display(message, rule.display);
+  }
+
+  registerStrategies(strategies: IDisplayStrategy[]): void {
+    strategies.forEach(strategy => {
+      if (!this.strategies.find(s => s.name === strategy.name)) {
+        this.strategies.push(strategy);
+        console.log(`✅ Registered strategy: ${strategy.name}`);
+      }
+    });
+  }
+
+  setRules(rules: DisplayRule[]): void {
+    this.rules = rules;
+    console.log(`📋 MessageDisplayRouterService: Rules updated (${rules.length} rules)`);
+  }
+}

package/src/lib/message-display/strategies/snackbar.strategy.ts

@@ -0,0 +1,46 @@
+import { Injectable, inject } from '@angular/core';
+import { ToastMessageDisplayService, ToastColors } from 'toast-message-display';
+import { IDisplayStrategy } from '../models/display-strategy.interface';
+import { CommunicationMessage } from '../models/communication-message.model';
+import { DisplayConfig } from '../models/display-config.model';
+
+@Injectable()
+export class SnackbarStrategy implements IDisplayStrategy {
+  name = 'snackbar';
+
+  private toastService = inject(ToastMessageDisplayService);
+
+  canHandle(message: CommunicationMessage): boolean {
+    return true;  // Always can handle (fallback strategy)
+  }
+
+  display(message: CommunicationMessage, config: DisplayConfig): void {
+    const messageText = this.extractMessage(message.content);
+
+    this.toastService.toastMessage(
+      {
+        message: messageText,
+        color: ToastColors.INFO,
+        icon: 'info',
+        action: 'DONE'
+      },
+      config.autoDismiss ?? 3000
+    );
+  }
+
+  private extractMessage(content: any): string {
+    if (!content) return '';
+
+    // Try nested content structure (backward compatibility)
+    if (content.content?.message) {
+      return content.content.message;
+    }
+
+    // Try direct message
+    if (content.message) {
+      return content.message;
+    }
+
+    return '';
+  }
+}

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

@@ -0,0 +1,33 @@
+export interface BatchOptionsInterface {
+  mode?: 'sequential' | 'parallel';
+  stopOnError?: boolean;
+  concurrency?: number;
+  ignoreErrors?: boolean;
+  logErrors?: boolean;
+  displaySuccess?: boolean;
+  displayError?: boolean;
+}
+
+export class BatchOptions implements BatchOptionsInterface {
+  constructor(
+    public mode: 'sequential' | 'parallel' = 'sequential',
+    public stopOnError: boolean = false,
+    public concurrency: number = 3,
+    public ignoreErrors: boolean = false,
+    public logErrors: boolean = true,
+    public displaySuccess?: boolean,
+    public displayError?: boolean,
+  ) {}
+
+  static adapt(item?: any): BatchOptions {
+    return new BatchOptions(
+      item?.mode ?? 'sequential',
+      item?.stopOnError ?? false,
+      item?.concurrency ?? 3,
+      item?.ignoreErrors ?? false,
+      item?.logErrors !== false,
+      item?.displaySuccess ?? false,
+      item?.displayError ?? false,
+    );
+  }
+}

package/src/lib/models/batch-progress.model.ts

@@ -0,0 +1,19 @@
+import { BatchRequestState } from './batch-request-state.model';
+
+export interface BatchProgress {
+  total: number;
+  pending: number;
+  completed: number;
+  failed: number;
+  percent: number;
+}
+
+export function calculateBatchProgress<T>(states: BatchRequestState<T>[]): BatchProgress {
+  const total = states.length;
+  const pending = states.filter(s => s.isPending).length;
+  const completed = states.filter(s => !s.isPending && s.data !== undefined).length;
+  const failed = states.filter(s => !s.isPending && s.error !== undefined).length;
+  const percent = total > 0 ? Math.round(((completed + failed) / total) * 100) : 0;
+
+  return { total, pending, completed, failed, percent };
+}

package/src/lib/models/batch-request-state.model.ts

@@ -0,0 +1,40 @@
+export type BatchRequestState<T> = 
+  | BatchPendingState
+  | BatchSuccessState<T>
+  | BatchErrorState;
+
+export interface BatchPendingState {
+  index: number;
+  request: any;
+  isPending: true;
+  data?: undefined;
+  error?: undefined;
+}
+
+export interface BatchSuccessState<T> {
+  index: number;
+  request: any;
+  isPending: false;
+  data: T;
+  error?: undefined;
+}
+
+export interface BatchErrorState {
+  index: number;
+  request: any;
+  isPending: false;
+  data?: undefined;
+  error: any;
+}
+
+export function isPendingState<T>(state: BatchRequestState<T>): state is BatchPendingState {
+  return state.isPending === true;
+}
+
+export function isSuccessState<T>(state: BatchRequestState<T>): state is BatchSuccessState<T> {
+  return state.isPending === false && state.data !== undefined;
+}
+
+export function isErrorState<T>(state: BatchRequestState<T>): state is BatchErrorState {
+  return state.isPending === false && state.error !== undefined;
+}

package/src/lib/models/batch-result.model.ts

@@ -0,0 +1,30 @@
+export interface BatchResultInterface<T = any> {
+  request: any;
+  success: boolean;
+  data?: T;
+  error?: any;
+  index: number;
+  timestamp: number;
+}
+
+export class BatchResult<T = any> implements BatchResultInterface<T> {
+  constructor(
+    public request: any,
+    public success: boolean,
+    public data?: T,
+    public error?: any,
+    public index: number = 0,
+    public timestamp: number = Date.now(),
+  ) {}
+
+  static adapt<T>(item?: any): BatchResult<T> {
+    return new BatchResult<T>(
+      item?.request,
+      item?.success ?? false,
+      item?.data,
+      item?.error,
+      item?.index ?? 0,
+      item?.timestamp ?? Date.now(),
+    );
+  }
+}

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

@@ -0,0 +1,45 @@
+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
+  displaySuccess?: 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,
+    public displaySuccess?: 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,
+      (item?.displaySuccess) ? item.displaySuccess : 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,16 @@
+export * from './database-storage.model'
+export * from './retry-options.model'
+export * from './batch-options.model'
+export * from './batch-result.model'
+export * from './batch-request-state.model'
+export * from './batch-progress.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 './upload-validation-error.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/models/upload-validation-error.model.ts

@@ -0,0 +1,46 @@
+export interface InvalidFileInfoInterface {
+  fileName: string;
+  fileSize: number;
+  fileType: string;
+  errors: string[];
+}
+
+export class InvalidFileInfoModel implements InvalidFileInfoInterface {
+  constructor(
+    public fileName: string = '',
+    public fileSize: number = 0,
+    public fileType: string = '',
+    public errors: string[] = []
+  ) {}
+
+  static adapt(item?: any): InvalidFileInfoModel {
+    return new InvalidFileInfoModel(
+      item?.fileName,
+      item?.fileSize,
+      item?.fileType,
+      Array.isArray(item?.errors) ? item.errors : []
+    );
+  }
+}
+
+export interface UploadValidationErrorInterface {
+  invalidFiles: InvalidFileInfoModel[];
+  validFilesCount: number;
+  totalFilesCount: number;
+}
+
+export class UploadValidationErrorModel implements UploadValidationErrorInterface {
+  constructor(
+    public invalidFiles: InvalidFileInfoModel[] = [],
+    public validFilesCount: number = 0,
+    public totalFilesCount: number = 0
+  ) {}
+
+  static adapt(item?: any): UploadValidationErrorModel {
+    return new UploadValidationErrorModel(
+      Array.isArray(item?.invalidFiles) ? item.invalidFiles.map((f: any) => InvalidFileInfoModel.adapt(f)) : [],
+      item?.validFilesCount,
+      item?.totalFilesCount
+    );
+  }
+}