http-request-manager 18.7.20 → 18.7.21

package/src/lib/services/utils/random-color.utils.ts

@@ -0,0 +1,83 @@
+/**
+ * Generate a random hex color code
+ * @returns A random hex color string (e.g., "#FF5733")
+ */
+export const RandomHexColor = (): string => {
+  // Generate a random number between 0 and 16777215 (0xFFFFFF)
+  const randomColor = Math.floor(Math.random() * 16777215);
+  // Convert to hexadecimal and pad with zeros to ensure 6 digits
+  const hexColor = randomColor.toString(16).padStart(6, '0');
+  // Return with # prefix
+  return `#${hexColor}`;
+};
+
+/**
+ * Generate a random hex color with constraints to ensure good visibility
+ * @param options Optional constraints for color generation
+ * @returns A random hex color string with good contrast
+ */
+export const RandomVisibleColor = (options?: {
+  minBrightness?: number; // Minimum brightness (0-255), default: 50
+  maxBrightness?: number; // Maximum brightness (0-255), default: 200
+}): string => {
+  const minBrightness = options?.minBrightness ?? 50;
+  const maxBrightness = options?.maxBrightness ?? 200;
+
+  // Generate RGB values within the specified brightness range
+  const r = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
+  const g = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
+  const b = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
+
+  // Convert to hex and pad with zeros
+  const toHex = (n: number) => n.toString(16).padStart(2, '0');
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+};
+
+/**
+ * Generate a random color from a predefined palette
+ * @returns A hex color from a set of visually distinct colors
+ */
+export const RandomPaletteColor = (): string => {
+  const colorPalette = [
+    '#FF6B6B', // Coral
+    '#4ECDC4', // Turquoise
+    '#45B7D1', // Sky Blue
+    '#FFBE0B', // Amber
+    '#FB5607', // Orange
+    '#8338EC', // Violet
+    '#3A86FF', // Azure
+    '#38B000', // Green
+    '#9D4EDD', // Purple
+    '#FF006E', // Pink
+    '#0077B6', // Blue
+    '#2A9D8F'  // Teal
+  ];
+
+  const randomIndex = Math.floor(Math.random() * colorPalette.length);
+  return colorPalette[randomIndex];
+};
+
+/**
+ * Generate a random HSL color
+ * @param options Optional constraints for HSL generation
+ * @returns A random HSL color string (e.g., "hsl(120, 100%, 50%)")
+ */
+export const RandomHSLColor = (options?: {
+  saturation?: [number, number]; // Saturation range (0-100), default: [50, 100]
+  lightness?: [number, number];   // Lightness range (0-100), default: [40, 80]
+}): string => {
+  // Full range for hue (0-360)
+  const hue = Math.floor(Math.random() * 361);
+
+  // Default or custom saturation range
+  const satMin = options?.saturation?.[0] ?? 50;
+  const satMax = options?.saturation?.[1] ?? 100;
+  const saturation = Math.floor(Math.random() * (satMax - satMin + 1) + satMin);
+
+  // Default or custom lightness range
+  const lightMin = options?.lightness?.[0] ?? 40;
+  const lightMax = options?.lightness?.[1] ?? 80;
+  const lightness = Math.floor(Math.random() * (lightMax - lightMin + 1) + lightMin);
+
+  return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
+};

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,4 @@
+
+export * from "./models/index";
+export * from "./services/websocket.service";
+

package/src/lib/services/ws-manager-service/models/channel-info.model.ts

@@ -0,0 +1,24 @@
+export interface ChannelInfoInterface {
+  name: string
+  canSubscribe: boolean
+}
+
+export class ChannelInfo implements ChannelInfoInterface {
+
+  constructor(
+    public name = '',
+    public canSubscribe = false,
+  ) {}
+
+  static adapt(item?: any): ChannelInfo {
+
+    return new ChannelInfo(
+      item?.name,
+      item?.canSubscribe,
+    )
+
+  }
+
+}
+
+

package/src/lib/services/ws-manager-service/models/channel-message-data.model.ts

@@ -0,0 +1,24 @@
+import { UserMessage } from "./user-message.model"
+
+export interface ChannelMessageInterface {
+    channel: string,
+    users: UserMessage[],
+}
+
+export class ChannelMessage implements ChannelMessageInterface {
+
+  constructor(
+    public channel: string,
+    public users: UserMessage[] = [],
+  ) {}
+
+  static adapt(item?: any): ChannelMessage {
+
+    return new ChannelMessage(
+      item?.channel,
+      (item?.users) ? item?.users.map((userItem: any) => UserMessage.adapt(userItem)) : [],
+    )
+
+  }
+
+}

package/src/lib/services/ws-manager-service/models/channel-message.model.ts

@@ -0,0 +1,24 @@
+import { WSUser } from "./ws-user.model";
+
+export interface ChannelMessageInterface {
+    sessionId: any,
+    content: any,
+}
+
+export class ChannelMessage implements ChannelMessageInterface {
+
+  constructor(
+    public sessionId: any = null,
+    public content: any = null,
+  ) {}
+
+  static adapt(item?: any): ChannelMessage {
+
+    return new ChannelMessage(
+      item?.sessionId || item?.id,  // Support both for backward compatibility
+      item?.content,
+    )
+
+  }
+
+}

package/src/lib/services/ws-manager-service/models/communication-type.enum.ts

@@ -0,0 +1,5 @@
+export enum CommunicationType {
+  MESSAGE,
+  ALERT,
+  OTHER
+}

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

@@ -0,0 +1,5 @@
+export * from "./channel-info.model";
+export * from "./ws-user.model";
+
+export * from "./communication-type.enum";
+

package/src/lib/services/ws-manager-service/models/ws-user.model.ts

@@ -0,0 +1,38 @@
+export interface WSUserInterface {
+    id: string,
+    ldap?: string,
+    name?: string,
+    email?: string,
+    [key: string]: any,  // Allow additional properties
+}
+
+export class WSUser implements WSUserInterface {
+
+  constructor(
+    public id: string = '',
+    public ldap: string = '',
+    public name: string = '',
+    public email: string = '',
+  ) {}
+
+  static adapt(item?: any): WSUser {
+    const user = new WSUser(
+      item?.id || item?.sessionId,  // Support both for backward compatibility
+      item?.ldap,
+      item?.name,
+      item?.email,
+    );
+    // Copy any additional properties
+    if (item) {
+      Object.keys(item).forEach(key => {
+        if (!['id', 'sessionId', 'ldap', 'name', 'email'].includes(key)) {
+          (user as any)[key] = item[key];
+        }
+      });
+    }
+    return user;
+  }
+
+}
+
+

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

@@ -0,0 +1,3 @@
+
+export * from "./websocket.service";
+