All files / src/app/shared/services formatter.service.ts

83.72% Statements 36/43
79.17% Branches 19/24
83.33% Functions 5/6
82.05% Lines 32/39

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80109x   109x         109x     1987x 994x 286x   994x 115x   879x 879x 879x 879x     879x 814x   879x                     3028x 1757x 1757x 1757x 1757x 696x   1061x 1061x 1034x   1061x           109x                           109x 489x 489x   489x 489x         109x  
import { Injectable } from '@angular/core';
 
import * as _ from 'lodash';
 
@Injectable({
  providedIn: 'root'
})
export class FormatterService {
  constructor() {}
 
  format_number(n: any, divisor: number, units: string[], decimals: number = 1): string {
    if (_.isString(n)) {
      n = Number(n);
    }
    if (!_.isNumber(n)) {
      return '-';
    }
    let unit = n < 1 ? 0 : Math.floor(Math.log(n) / Math.log(divisor));
    unit = unit >= units.length ? units.length - 1 : unit;
    let result = _.round(n / Math.pow(divisor, unit), decimals).toString();
    Iif (result === '') {
      return '-';
    }
    if (units[unit] !== '') {
      result = `${result} ${units[unit]}`;
    }
    return result;
  }
 
  /**
   * Convert the given value into bytes.
   * @param {string} value The value to be converted, e.g. 1024B, 10M, 300KiB or 1ZB.
   * @param error_value The value returned in case the regular expression did not match. Defaults to
   *                    null.
   * @returns Returns the given value in bytes without any unit appended or the defined error value
   *          in case xof an error.
   */
  toBytes(value: string, error_value = null): number | null {
    const base = 1024;
    const units = ['b', 'k', 'm', 'g', 't', 'p', 'e', 'z', 'y'];
    const m = RegExp('^(\\d+(.\\d+)?) ?([' + units.join('') + ']?(b|ib|B/s)?)?$', 'i').exec(value);
    if (m === null) {
      return error_value;
    }
    let bytes = parseFloat(m[1]);
    if (_.isString(m[3])) {
      bytes = bytes * Math.pow(base, units.indexOf(m[3].toLowerCase()[0]));
    }
    return Math.round(bytes);
  }
 
  /**
   * Converts `x ms` to `x` (currently) or `0` if the conversion fails
   */
  toMilliseconds(value: string): number {
    const pattern = /^\s*(\d+)\s*(ms)?\s*$/i;
    const testResult = pattern.exec(value);
 
    if (testResult !== null) {
      return +testResult[1];
    }
 
    return 0;
  }
 
  /**
   * Converts `x IOPS` to `x` (currently) or `0` if the conversion fails
   */
  toIops(value: string): number {
    const pattern = /^\s*(\d+)\s*(IOPS)?\s*$/i;
    const testResult = pattern.exec(value);
 
    Eif (testResult !== null) {
      return +testResult[1];
    }
 
    return 0;
  }
}