http-request-manager 18.7.21 → 18.7.27

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

@@ -1,83 +0,0 @@
-/**
- * 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

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

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

@@ -1,4 +0,0 @@
-
-export * from "./models/index";
-export * from "./services/websocket.service";
-

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

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

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

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

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

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

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

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

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