http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/utils/utils.service.spec.ts

@@ -0,0 +1,165 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
+import { UtilsService } from './utils.service';
+import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+
+describe('UtilsService', () => {
+  let service: UtilsService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+    imports: [],
+    providers: [UtilsService, provideHttpClient(withInterceptorsFromDi()), provideHttpClientTesting()]
+});
+    service = TestBed.inject(UtilsService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('Type Checks and JSON Conversions', () => {
+    it('should check string and object types', () => {
+      expect(service.isString('test')).toBeTrue();
+      expect(service.isString(123)).toBeFalse();
+      expect(service.isObject({})).toBeTrue();
+      expect(service.isObject('test')).toBeFalse();
+    });
+
+    it('should convert between JSON and string', () => {
+      const obj = { key: 'value' };
+      const jsonString = '{"key":"value"}';
+      expect(service.JSONToString(obj)).toBe(JSON.stringify(obj));
+      expect(service.JSONToString('test')).toBe('test');
+      expect(service.stringToJSON(jsonString)).toEqual(JSON.parse(jsonString));
+      expect(service.stringToJSON('test')).toBe('test');
+    });
+
+    it('should check if a string is valid JSON', () => {
+      expect(service.isJSON('{"key":"value"}')).toBeTrue();
+      expect(service.isJSON('not json')).toBeFalse();
+    });
+  });
+
+  describe('Object Access and Comparison', () => {
+    it('should return property value and compare objects', () => {
+      const obj = { key: 'value' };
+      expect(service.getValueByProp(obj, 'key')).toBe('value');
+      expect(service.getValueByProp(undefined, 'key')).toBeFalse();
+
+      const obj1 = { key: 'value', nested: { a: 1 } };
+      const obj2 = { key: 'value', nested: { a: 1 } };
+      const obj3 = { key: 'value', nested: { a: 2 } };
+      expect(service.objectsEqual(obj1, obj2)).toBeTrue();
+      expect(service.objectsEqual(obj1, obj3)).toBeFalse();
+    });
+  });
+
+  describe('HTTP and Getter', () => {
+    it('should obtain JSON from file', () => {
+      const dummyData = { key: 'value' };
+      service.getJSON('test.json').subscribe(data => {
+        expect(data).toEqual(dummyData);
+      });
+      const req = httpMock.expectOne('assets/data/test.json');
+      expect(req.request.method).toBe('GET');
+      req.flush(dummyData);
+    });
+
+    it('should return current time from today getter', () => {
+      const nowInSec = new Date().getMilliseconds() / 1000;
+      expect(service.today).toBeCloseTo(nowInSec, 0);
+    });
+  });
+
+  describe('Conversion Methods', () => {
+    it('should convert base32 to hex (simple case)', () => {
+      // For "A", expecting "0".
+      expect(service.base32ToHex('A')).toBe('0');
+    });
+
+    it('should convert binary to hex with 32-character padding', () => {
+      /* For the binary representation of "Hello":
+         H -> 01001000
+         e -> 01100101
+         l -> 01101100
+         l -> 01101100
+         o -> 01101111
+         -> Hex: "48656c6c6f"
+         Padded (22 zeros in front): "00000000000000000000000048656c6c6f"
+      */
+      const binary = '0100100001100101011011000110110001101111';
+      const expected = '000000000000000000000048656c6c6f';
+      expect(service.binaryToHex(binary)).toBe(expected);
+    });
+  });
+
+  describe('Expiry Calculations', () => {
+    // Helper to test expiry() returns a value close to now + (multiplier)
+    function expectExpiryClose(input: string, multiplier: number) {
+      const now = Math.floor(new Date().getTime() / 1000);
+      const expiry = service.expires(input);
+      expect(expiry).toBeGreaterThanOrEqual(now + multiplier - 1);
+      expect(expiry).toBeLessThanOrEqual(now + multiplier + 1);
+    }
+
+    it('should calculate expiry for various time units', () => {
+      expectExpiryClose("1y", 31556926);
+      expectExpiryClose("1m", 2629743);
+      expectExpiryClose("1w", 604800);
+      expectExpiryClose("1d", 86400);
+      expectExpiryClose("1hr", 3600);
+      expectExpiryClose("1mn", 60);
+      expectExpiryClose("1s", 1);
+    });
+
+    it('should return undefined for missing expiry string', () => {
+      expect(service.expires()).toBeUndefined();
+    });
+
+    it('should indicate if expired', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      expect(service.hasExpired(now - 10)).toBeTrue();
+      expect(service.hasExpired(now + 10)).toBeFalse();
+      expect(service.hasExpired(0)).toBeFalse();
+    });
+
+    it('should check setting for expiry', () => {
+      const settingWithExpiry = { expires: 1234567890 };
+      const settingWithoutExpiry = { key: 'value' };
+      expect(service.hasExpiry(settingWithExpiry)).toBeTrue();
+      expect(service.hasExpiry(settingWithoutExpiry)).toBeFalse();
+    });
+
+    it('should return a formatted string for future expiry dates', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      const future = now + 10000;
+      const result = service.expiresIn(future);
+      expect(typeof result).toBe('string');
+      expect(result).toBeDefined();
+      expect(result!.length).toBeGreaterThan(0);
+      // Expect one of the time unit labels in the formatted result.
+      expect(result).toMatch(/(y|m|w|d|h|min|s)/);
+    });
+
+    it('should return "Expired" for past or current expiry dates', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      expect(service.expiresIn(now - 1)).toBe("Expired");
+      expect(service.expiresIn(now)).toBe("Expired");
+    });
+  });
+
+  describe('String Conversion', () => {
+    it('should convert string to lowercase with underscores', () => {
+      const input = 'Hello, World!';
+      // Expected conversion: remove punctuation, convert to lowercase, replace spaces with underscores.
+      expect(service.lc(input)).toBe('hello_world');
+    });
+  });
+});

package/src/lib/services/utils/utils.service.ts

@@ -0,0 +1,192 @@
+
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UtilsService {
+
+  http = inject(HttpClient)
+
+  constructor() { }
+
+  isString(x: string | number) {
+    return Object.prototype.toString.call(x) === '[object String]'
+  }
+
+  isObject(obj: any) {
+    return Object.prototype.toString.call(obj) === '[object Object]'
+  }
+
+  JSONToString(value: any) {
+    return (this.isObject(value)) ? JSON.stringify(value) : value
+  }
+
+  stringToJSON(value: string) {
+    return (this.isJSON(value)) ? JSON.parse(value) : value
+  }
+
+  isJSON(str: any) {
+    try {
+      JSON.parse(str)
+    } catch (e) {
+      return false
+    }
+    return true
+  }
+
+  getValueByProp(obj: any, prop: string) {
+    if(typeof obj === 'undefined') return false
+    return obj[prop]
+  }
+
+  objectsEqual(x: any, y: any): boolean {
+
+    const ok = Object.keys, tx = typeof x, ty = typeof y
+
+    return x && y && tx === 'object' && tx === ty ? (
+      ok(x).length === ok(y).length &&
+        ok(x).every((key: any) => this.objectsEqual(x[key], y[key]))
+    ) : (x === y)
+
+  }
+
+  getJSON(file: string) {
+    return this.http.get(`assets/data/${file}`)
+  }
+
+  get today() {
+    return new Date().getMilliseconds() / 1000
+  }
+
+  base32ToHex(base32: string): string {
+
+    const base32chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+
+    const charToValue = (char: string) => base32chars.indexOf(char.toUpperCase())
+
+    let bits = ''
+    let hex = ''
+
+    for (let i = 0; i < base32.length; i++) {
+      const val = charToValue(base32.charAt(i))
+      bits += val.toString(2).padStart(5, '0')
+    }
+
+    for (let i = 0; i + 4 <= bits.length; i += 4) {
+      const chunk = bits.substr(i, 4)
+      hex += parseInt(chunk, 2).toString(16)
+    }
+
+    return hex.toUpperCase()
+  }
+
+  binaryToHex(binary: string): string {
+    let hex = '';
+    for (let i = 0; i < binary.length; i += 8) {
+      const byte = binary.substr(i, 8);
+      const decimal = parseInt(byte, 2);
+      hex += decimal.toString(16).padStart(2, '0');
+    }
+    return hex.padStart(32, '0').substr(0, 32);
+  }
+
+  // y = years, m = months, w = weeks, d = days, hr = hours, mn = minutes else seconds
+  // returns epoch time corresponding to the expiry type
+  expires(str?: string) {
+
+    if(!str) return undefined
+
+    const match = str.match(/[^0-9]+$/)
+
+    const type = (match) ? str.slice(-match[0].length) : 0
+
+    const now = Math.floor(new Date().getTime() / 1000)
+
+    let value = 0;
+
+    switch (type) {
+      case
+      'y':
+        const years = parseInt(str.slice(0, -1))
+        value = now + (years * 31556926)
+        break;
+      case
+      'm':
+        const months = parseInt(str.slice(0, -1))
+        value = now + (months * 2629743)
+        break;
+      case
+      'w':
+        const weeks = parseInt(str.slice(0, -1))
+        value = now + (weeks * 604800)
+        break;
+      case
+      'd':
+        const days = parseInt(str.slice(0, -1))
+        value = now + (days * 86400)
+        break;
+      case
+      'hr':
+        const hrs = parseInt(str.slice(0, -2))
+        value = now + (hrs * 3600)
+        break;
+      case
+      'mn':
+        const min = parseInt(str.slice(0, -2))
+        value = now + (min * 60)
+        break;
+      default: //seconds
+        const sec = parseInt(str.slice(0, -1))
+        value = now + sec
+        break;
+    }
+    return value;
+  }
+
+  hasExpired(expiryDate: number): boolean {
+    if (!expiryDate || expiryDate === 0) return false
+    const currentTime = Math.floor(new Date().getTime() / 1000)
+    return expiryDate < currentTime
+  }
+
+  hasExpiry(setting: any) {
+    return (setting?.expires) ? true : false
+  }
+
+  expiresIn(expiryDate: number) {
+
+    if (!expiryDate) return;
+
+    const now = Math.floor(new Date().getTime() / 1000);
+    let diff = expiryDate - now;
+
+    if (diff <= 0) return "Expired";
+
+    const units = [
+        { label: 'y', s: 31536000 },
+        { label: 'm', s: 2592000 },
+        { label: 'w', s: 604800 },
+        { label: 'd', s: 86400 },
+        { label: 'h', s: 3600 },
+        { label: 'min', s: 60 },
+        { label: 's', s: 1 },
+    ];
+
+    let result = [];
+
+    for (const unit of units) {
+        if (diff >= unit.s) {
+            const value = Math.floor(diff / unit.s);
+            diff %= unit.s;
+            result.push(`${value}${unit.label}`);
+        }
+    }
+
+    return result.join(', ');
+  }
+
+  lc = (str: string) => str.toLowerCase().replace(/[^\w\s]/g, '').replace(/\s+/g, '_')
+
+}

package/src/lib/services/ws-manager-service/index.ts

@@ -0,0 +1,13 @@
+
+export * from "./models/index";
+export * from "./services/websocket.service";
+export * from "./websocket-service/index";
+
+export { WebSocketMessageService } from "./services/websocket-message.service";
+export { WebSocketSignalsManagerService } from "./websocket-signals-manager.service";
+export { MessageTrackerSignalsService } from "./message-tracker-signals.service";
+export { StateMessage, StateMessageInterface } from "./models/state-message.model";
+export { PublicMessage, PublicMessageInterface } from "./models/public-message.model";
+export { NotificationMessage, NotificationMessageInterface } from "./models/notification-message.model";
+// ChannelType is already exported from request-manager-state-service to avoid conflicts
+

package/src/lib/services/ws-manager-service/message-tracker-signals.service.ts

@@ -0,0 +1,147 @@
+import { Injectable, inject, signal, computed, effect } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { WebSocketSignalsManagerService } from './websocket-signals-manager.service';
+
+/**
+ * MessageTrackerSignalsService - Signal-based message tracking
+ *
+ * Tracks WebSocket messages, channel metadata, and user presence using signals.
+ * Provides real-time reactivity for message-driven applications.
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class MessageTrackerSignalsService {
+
+  private wsManager = inject(WebSocketSignalsManagerService);
+
+  // Signal-based state
+  private messagesSignal = signal<any>(null);
+  public readonly messages = this.messagesSignal.asReadonly();
+  public readonly messages$ = toObservable(this.messagesSignal);
+
+  private channelMetadataSignal = signal<Map<string, any>>(new Map());
+  public readonly channelMetadata = this.channelMetadataSignal.asReadonly();
+  public readonly channelMetadata$ = toObservable(this.channelMetadataSignal);
+
+  private usersInChannelsSignal = signal<Map<string, Set<string>>>(new Map());
+  public readonly usersInChannels = this.usersInChannelsSignal.asReadonly();
+  public readonly usersInChannels$ = toObservable(this.usersInChannelsSignal);
+
+  // Computed signals for derived state
+  readonly messageCount = computed(() => {
+    const metadata = this.channelMetadataSignal();
+    let count = 0;
+    metadata.forEach(data => count += data.count);
+    return count;
+  });
+
+  readonly activeChannels = computed(() => {
+    return Array.from(this.channelMetadataSignal().keys());
+  });
+
+  constructor() {
+    // Track messages from WebSocket
+    effect(() => {
+      const message = this.wsManager.messages();
+      if (message) {
+        this.trackMessage(message);
+      }
+    });
+
+    // Track connection status
+    effect(() => {
+      const connected = this.wsManager.connectionStatus();
+      if (!connected) {
+        this.onDisconnect();
+      }
+    });
+  }
+
+  trackMessage(message: any): void {
+    // Store message
+    this.messagesSignal.set(message);
+
+    // Update channel metadata
+    if (message.channel) {
+      this.updateChannelMetadata(message.channel, message);
+    }
+
+    // Update user presence if applicable
+    if (message.user && message.channel) {
+      this.updateUserPresence(message.channel, message.user);
+    }
+  }
+
+  private updateChannelMetadata(channel: string, message: any): void {
+    this.channelMetadataSignal.update(metadata => {
+      const updated = new Map(metadata);
+      const current = updated.get(channel) || { count: 0, lastMessage: null, lastUpdated: 0 };
+      updated.set(channel, {
+        ...current,
+        count: current.count + 1,
+        lastMessage: message,
+        lastUpdated: Date.now()
+      });
+      return updated;
+    });
+  }
+
+  private updateUserPresence(channel: string, user: string): void {
+    this.usersInChannelsSignal.update(users => {
+      const updated = new Map(users);
+      const channelUsers = new Set(updated.get(channel) || []);
+      channelUsers.add(user);
+      updated.set(channel, channelUsers);
+      return updated;
+    });
+  }
+
+  removeUserFromChannel(channel: string, user: string): void {
+    this.usersInChannelsSignal.update(users => {
+      const updated = new Map(users);
+      const channelUsers = updated.get(channel);
+      if (channelUsers) {
+        channelUsers.delete(user);
+        updated.set(channel, channelUsers);
+      }
+      return updated;
+    });
+  }
+
+  subscribeToChannel(channel: string): void {
+    this.wsManager.subscribeToChannel(channel);
+  }
+
+  unsubscribeFromChannel(channel: string): void {
+    this.wsManager.unsubscribeFromChannel(channel);
+    this.removeUserFromChannel(channel, 'current-user');
+  }
+
+  // Selectors
+  getMessageCount(channel: string): number {
+    const metadata = this.channelMetadataSignal();
+    return metadata.get(channel)?.count || 0;
+  }
+
+  getLastMessage(channel: string): any {
+    const metadata = this.channelMetadataSignal();
+    return metadata.get(channel)?.lastMessage || null;
+  }
+
+  getActiveChannels(): string[] {
+    return Array.from(this.channelMetadataSignal().keys());
+  }
+
+  getUsersInChannel(channel: string): string[] {
+    const users = this.usersInChannelsSignal().get(channel);
+    return users ? Array.from(users) : [];
+  }
+
+  private onDisconnect(): void {
+    // Clear state on disconnect
+    this.messagesSignal.set(null);
+    this.channelMetadataSignal.set(new Map());
+    this.usersInChannelsSignal.set(new Map());
+  }
+}