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

83.33% Statements 30/36
87.5% Branches 7/8
80% Functions 4/5
81.25% Lines 26/32

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
    80
    81
    82103x

    103x

    103x

    103x

    1819x

    374x

    26x

    884x
    884x
    884x

    747x

    884x

    1350x
    897x
    897x
    897x

    105x

    792x

    765x

    792x

    103x

    103x
    447x
    447x

    447x

    103x
     import { Injectable } from '@angular/core';

    import * as _ from 'lodash';

    import { ServicesModule } from './services.module';

    @Injectable({
      providedIn: ServicesModule
    })
    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();
        if (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);

        if (testResult !== null) {
          return +testResult[1];
        }

        return 0;
      }
    }