@smartsoft001/utils 2.76.0 → 2.81.0

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

@@ -1,56 +0,0 @@
-import { ArrayService } from './array.service';
-
-describe('shared-utils: ArrayService', () => {
-  describe('addItem()', () => {
-    it('should add element to array', () => {
-      const array = [1];
-
-      ArrayService.addItem(array, 2);
-
-      expect(array[1]).toBe(2);
-    });
-
-    it('should create new array', () => {
-      const array = [1];
-
-      const newArray = ArrayService.addItem(array, 2);
-
-      expect(array).not.toBe(newArray);
-      expect(array[0]).toBe(newArray[0]);
-      expect(array[1]).toBe(newArray[1]);
-    });
-  });
-
-  describe('removeItem()', () => {
-    it('should remove element from array', () => {
-      const array = [1, 2];
-
-      ArrayService.removeItem(array, 2);
-
-      expect(array.length).toBe(1);
-      expect(!!array[1]).not.toBeTruthy();
-    });
-
-    it('should create new array', () => {
-      const array = [1, 2];
-
-      const newArray = ArrayService.removeItem(array, 2);
-
-      expect(array).not.toBe(newArray);
-      expect(array[0]).toBe(newArray[0]);
-      expect(!!array[1]).toBe(!!newArray[1]);
-    });
-
-    describe('sort()', () => {
-      it('should return sorted array', () => {
-        const array = [{ key: 2 }, { key: 1 }, { key: -1 }];
-
-        const result = ArrayService.sort(array, (item) => item.key);
-
-        expect(array[2]).toBe(result[0]);
-        expect(array[1]).toBe(result[1]);
-        expect(array[0]).toBe(result[2]);
-      });
-    });
-  });
-});

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

@@ -1,40 +0,0 @@
-import * as _ from 'lodash';
-
-export class ArrayService {
-  /**
-   * pushing item to input array and creating new array with same items
-   * @param array {array} - input array
-   * @param item {object} - new item
-   * @returns {array} - new array with item
-   */
-  static addItem<T>(array: Array<T>, item: T): Array<T> {
-    array.push(item);
-
-    return [...array];
-  }
-
-  /**
-   * removing item from input array and creating new array without item
-   * @param array {array} - input array
-   * @param item {object} - item to remove
-   * @returns {array} - new array without item
-   */
-  static removeItem<T>(array: Array<T>, item: T): Array<T> {
-    const index = array.indexOf(item);
-    if (index > -1) {
-      array.splice(index, 1);
-    }
-
-    return [...array];
-  }
-
-  /**
-   * sort array
-   * @param array {array} - input array
-   * @param by {function} - function to get sort key
-   * @returns {array} - sorted array
-   */
-  static sort<T>(array: Array<T>, by: (item: T) => unknown): Array<T> {
-    return _.sortBy(array, by);
-  }
-}

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

@@ -1,10 +0,0 @@
-import { Guid } from 'guid-typescript';
-
-import { GuidService } from './guid.service';
-
-describe('shared-utils: GuidService', () => {
-  it('should create correct guid', () => {
-    const guid = GuidService.create();
-    expect(Guid.isGuid(guid)).toBeTruthy();
-  });
-});

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

@@ -1,10 +0,0 @@
-import { Guid } from 'guid-typescript';
-
-export class GuidService {
-  /***
-   * Create guid as string
-   */
-  static create(): string {
-    return Guid.raw();
-  }
-}

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

@@ -1,31 +0,0 @@
-import { NipService } from './nip.service';
-
-describe('shared-utils: NipService', () => {
-  describe('isValid()', () => {
-    it('should return true when correct nip', () => {
-      const result = NipService.isValid('5372527048');
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should return false when incorrect nip', () => {
-      const result = NipService.isValid('5372527041');
-
-      expect(result).not.toBeTruthy();
-    });
-  });
-
-  describe('isInvalid()', () => {
-    it('should return false when correct nip', () => {
-      const result = NipService.isInvalid('5372527048');
-
-      expect(result).not.toBeTruthy();
-    });
-
-    it('should return true when incorrect nip', () => {
-      const result = NipService.isInvalid('5372527041');
-
-      expect(result).toBeTruthy();
-    });
-  });
-});

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

@@ -1,34 +0,0 @@
-export class NipService {
-  /***
-   * Check valid nip format
-   * @param nip {string} - nip string
-   * @return return true when correct
-   */
-  static isValid(nip: string): boolean {
-    if (typeof nip !== 'string') return false;
-
-    //eslint-disable-next-line
-    nip = nip.replace(/[\ \-]/gi, '');
-
-    const weight = [6, 5, 7, 2, 3, 4, 5, 6, 7];
-    let sum = 0;
-    // tslint:disable-next-line:radix
-    const controlNumber = parseInt(nip.substring(9, 10));
-    const weightCount = weight.length;
-    for (let i = 0; i < weightCount; i++) {
-      // tslint:disable-next-line:radix
-      sum += parseInt(nip.substr(i, 1)) * weight[i];
-    }
-
-    return sum % 11 === controlNumber;
-  }
-
-  /***
-   * Check invalid nip format
-   * @param nip {string} - nip string
-   * @return return true when incorrect
-   */
-  static isInvalid(nip: string): boolean {
-    return !NipService.isValid(nip);
-  }
-}

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

@@ -1,97 +0,0 @@
-import { ObjectService } from './object.service';
-
-describe('shared-utils: ObjectService', () => {
-  describe('createByType()', () => {
-    it('should return same object when exist same type', () => {
-      class Test {
-        test1?: string;
-      }
-      const instance = new Test();
-
-      const result = ObjectService.createByType(instance, Test);
-
-      expect(result).toBe(instance);
-    });
-
-    it('should return other object when is other type', () => {
-      class Test {
-        test1?: string;
-      }
-      class Test2 {
-        test1?: string;
-      }
-      const instance = new Test();
-
-      const result = ObjectService.createByType(instance, Test2);
-
-      expect(result).not.toBe(instance);
-    });
-
-    it('should return specific type when set object', () => {
-      class Test {
-        test1?: string;
-      }
-      const data = {
-        test1: 'test123',
-      };
-
-      const result: Test = ObjectService.createByType(data, Test);
-
-      expect(result.constructor).toBe(Test);
-      expect(result.test1).toBe(data.test1);
-    });
-  });
-
-  describe('removeTypes()', () => {
-    it('should remove type from object', function () {
-      class Test {
-        test1?: string;
-      }
-      const obj = new Test();
-
-      const result = ObjectService.removeTypes(obj);
-
-      expect(result.constructor).not.toBe(Test);
-    });
-
-    it('should set correct data', function () {
-      class Test {
-        test1?: string;
-      }
-      const obj = new Test();
-      obj.test1 = 'test123';
-
-      const result = ObjectService.removeTypes(obj);
-
-      expect(result.test1).toBe(obj.test1);
-    });
-
-    it('should remove only object types in parent', function () {
-      class Test {
-        test1?: string;
-        date?: Date;
-      }
-      const obj = new Test();
-      obj.test1 = 'test123';
-      obj.date = new Date();
-
-      const result = ObjectService.removeTypes(obj);
-
-      expect(result.date instanceof Date).toBeTruthy();
-    });
-
-    it('should handle null fields', function () {
-      class Test {
-        test1?: string;
-        date?: Date;
-      }
-      const obj = new Test();
-      obj.test1 = undefined;
-      obj.date = new Date();
-
-      ObjectService.removeTypes(obj);
-
-      expect(obj.test1 === undefined).toBeTruthy();
-    });
-  });
-});

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

@@ -1,55 +0,0 @@
-import { stringify } from 'flatted';
-
-export class ObjectService {
-  /***
-   * Create object with data
-   * @param data {object} - data to set
-   * @param type {type} - new type
-   * @return - new type object
-   */
-  static createByType<T>(data: any, type: any): T {
-    if (!data) return data as T;
-
-    try {
-      if (data instanceof type) return data as T;
-    } catch (e) {
-      console.warn(e);
-    }
-
-    const result = new type();
-
-    Object.keys(data).forEach((key) => {
-      result[key] = data[key];
-    });
-
-    return result;
-  }
-
-  /***
-   * Remove object type from data
-   * @param obj {object} - object
-   * @return - object without type
-   */
-  static removeTypes(obj: any): any {
-    if (!obj) return obj;
-
-    const result = {} as any;
-
-    Object.keys(obj).forEach((key) => {
-      if (obj[key] && obj[key].constructor && !(obj[key] instanceof Date)) {
-        let stringValue = '';
-        try {
-          stringValue = JSON.stringify(obj[key]);
-        } catch (e) {
-          console.warn("can't stringify without circular package");
-          stringValue = stringify(obj[key]);
-        }
-        result[key] = JSON.parse(stringValue);
-      } else {
-        result[key] = obj[key];
-      }
-    });
-
-    return result;
-  }
-}

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

@@ -1,18 +0,0 @@
-import { PasswordService } from './password.service';
-
-describe('shared-utils: PasswordService', () => {
-  it('should hash', async () => {
-    const result = await PasswordService.hash('test');
-
-    expect(result).toBeDefined();
-  });
-
-  it('should compare', async () => {
-    const password = 'test';
-    const hash = await PasswordService.hash(password);
-
-    const result = await PasswordService.compare(password, hash);
-
-    expect(result).toBeTruthy();
-  });
-});

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

@@ -1,25 +0,0 @@
-import * as md5_ from 'md5';
-
-const md5 = md5_;
-
-// @dynamic
-export class PasswordService {
-  /**
-   * Hash password text
-   * @param p {string} - text
-   * @return - hashed text
-   */
-  static hash(p: string): Promise<string> {
-    return Promise.resolve(md5(p));
-  }
-
-  /**
-   * Compare password text with hashed text
-   * @param p {string} - password text
-   * @param h {string} - hashed text
-   */
-  static async compare(p: string, h: string): Promise<boolean> {
-    const hp = await PasswordService.hash(p);
-    return hp === h;
-  }
-}

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

@@ -1,31 +0,0 @@
-import { PeselService } from './pesel.service';
-
-describe('shared-utils: PeselService', () => {
-  describe('isValid()', () => {
-    it('should return true when correct pesel', () => {
-      const result = PeselService.isValid('91012008616');
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should return false when incorrect pesel', () => {
-      const result = PeselService.isValid('91012008612');
-
-      expect(result).not.toBeTruthy();
-    });
-  });
-
-  describe('isInvalid()', () => {
-    it('should return false when correct pesel', () => {
-      const result = PeselService.isInvalid('91012008616');
-
-      expect(result).not.toBeTruthy();
-    });
-
-    it('should return true when incorrect pesel', () => {
-      const result = PeselService.isInvalid('91012008612');
-
-      expect(result).toBeTruthy();
-    });
-  });
-});

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

@@ -1,48 +0,0 @@
-export class PeselService {
-  /***
-   * Check valid pesel format
-   * @param pesel {string} - pesel string
-   * @return return true when correct
-   */
-  static isValid(pesel: string): boolean {
-    const reg = /^[0-9]{11}$/;
-    if (reg.test(pesel) === false) return false;
-    else {
-      const digits = ('' + pesel).split('');
-      // tslint:disable-next-line:radix
-      if (
-        parseInt(pesel.substring(4, 6)) > 31 ||
-        parseInt(pesel.substring(2, 4)) > 12
-      )
-        return false;
-
-      // tslint:disable-next-line:radix
-      let checksum =
-        (1 * parseInt(digits[0]) +
-          3 * parseInt(digits[1]) +
-          7 * parseInt(digits[2]) +
-          9 * parseInt(digits[3]) +
-          1 * parseInt(digits[4]) +
-          3 * parseInt(digits[5]) +
-          7 * parseInt(digits[6]) +
-          9 * parseInt(digits[7]) +
-          1 * parseInt(digits[8]) +
-          3 * parseInt(digits[9])) %
-        10;
-      if (checksum === 0) checksum = 10;
-      checksum = 10 - checksum;
-
-      // tslint:disable-next-line:radix
-      return parseInt(digits[10]) === checksum;
-    }
-  }
-
-  /***
-   * Check invalid pesel format
-   * @param pesel {string} - pesel string
-   * @return return true when incorrect
-   */
-  static isInvalid(pesel: string): boolean {
-    return !PeselService.isValid(pesel);
-  }
-}

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

@@ -1,67 +0,0 @@
-import { SpecificationService } from './specification.service';
-
-describe('shared-utils: SpecificationService', () => {
-  describe('valid()', () => {
-    it('should valid value', () => {
-      const criteria = { a: 'test' };
-      const value = { a: 'test' };
-
-      const result = SpecificationService.valid(value, { criteria });
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should invalid value', () => {
-      const criteria = { a: 'test' };
-      const value = { a: 'test2' };
-
-      const result = SpecificationService.valid(value, { criteria });
-
-      expect(result).not.toBeTruthy();
-    });
-
-    it('should valid array value', () => {
-      const criteria = { a: 'test1' };
-      const value = { a: ['test1', 'test2'] };
-
-      const result = SpecificationService.valid(value, { criteria });
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should invalid array value', () => {
-      const criteria = { a: 'test1' };
-      const value = { a: ['test2', 'test3'] };
-
-      const result = SpecificationService.valid(value, { criteria });
-
-      expect(result).not.toBeTruthy();
-    });
-  });
-
-  describe('getSqlCriteria()', () => {
-    it('should return string query for string criteria', () => {
-      const criteria = { a: 'test' };
-
-      const result = SpecificationService.getSqlCriteria({ criteria });
-
-      expect(result).toBe("a = 'test'");
-    });
-
-    it('should return number query for number criteria', () => {
-      const criteria = { a: 3 };
-
-      const result = SpecificationService.getSqlCriteria({ criteria });
-
-      expect(result).toBe('a = 3');
-    });
-
-    it('should return query with and key for many keys', () => {
-      const criteria = { a: 3, b: 'test' };
-
-      const result = SpecificationService.getSqlCriteria({ criteria });
-
-      expect(result).toBe("a = 3 and b = 'test'");
-    });
-  });
-});

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

@@ -1,85 +0,0 @@
-export interface ISpecificationCustom {
-  $root?: any;
-}
-
-export const SPECIFICATION_ROOT_KEY = '$root.';
-
-export class SpecificationService {
-  /**
-   * Checking if the value meets the specifications
-   * @param value {object} - object to check
-   * @param spec {ISpecificatio} - specification
-   * @param custom {ISpecificationCustom} - custom data for valid
-   */
-  static valid<T>(
-    value: T,
-    spec: { criteria: any },
-    custom?: ISpecificationCustom,
-  ): boolean {
-    const keys = Object.keys(spec.criteria);
-
-    if (!value) return false;
-
-    for (let index = 0; index < keys.length; index++) {
-      const key = keys[index];
-
-      if (key.indexOf(SPECIFICATION_ROOT_KEY) === 0 && custom?.$root) {
-        if (
-          !SpecificationService.check(
-            custom?.$root[key.replace(SPECIFICATION_ROOT_KEY, '')],
-            spec.criteria[key],
-          )
-        )
-          return false;
-      } else if (
-        !SpecificationService.check((value as any)[key], spec.criteria[key])
-      )
-        return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Checking if the object does not meet the specifications
-   * @param value {object} - object to check
-   * @param spec {ISpecificatio} - specification
-   * @param custom {ISpecificationCustom} - custom data for invalid
-   */
-  static invalid<T>(
-    value: T,
-    spec: { criteria: any },
-    custom?: ISpecificationCustom,
-  ): boolean {
-    return !SpecificationService.valid(value, spec, custom);
-  }
-
-  /**
-   * Convert specification to sql
-   * @param spec {ISpecificatio} - specification
-   * @return - sql criteria
-   */
-  static getSqlCriteria(spec: { criteria: any }): string {
-    const keys = Object.keys(spec.criteria);
-    let result = '';
-
-    for (let index = 0; index < keys.length; index++) {
-      const key = keys[index];
-      const val = spec.criteria[key];
-
-      if (index) result += ' and ';
-
-      result += `${key} = ${typeof val === 'number' ? val : "'" + val + "'"}`;
-    }
-
-    return result;
-  }
-
-  private static check(value: any, criteriaValue: any): boolean {
-    if (value && Array.isArray(value)) {
-      return value.some((i) => i === criteriaValue);
-    }
-
-    return value === criteriaValue;
-  }
-}

package/src/lib/services/zip-code/zip-code.service.spec.ts

@@ -1,31 +0,0 @@
-import { ZipCodeService } from './zip-code.service';
-
-describe('shared-utils: ZipCodeService', () => {
-  describe('isValid()', () => {
-    it('should return true when correct zip code', () => {
-      const result = ZipCodeService.isValid('01-123');
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should return false when incorrect zip code', () => {
-      const result = ZipCodeService.isValid('123123');
-
-      expect(result).not.toBeTruthy();
-    });
-  });
-
-  describe('isInvalid()', () => {
-    it('should return false when correct zip code', () => {
-      const result = ZipCodeService.isInvalid('01-123');
-
-      expect(result).not.toBeTruthy();
-    });
-
-    it('should return true when incorrect zip code', () => {
-      const result = ZipCodeService.isInvalid('123');
-
-      expect(result).toBeTruthy();
-    });
-  });
-});

package/src/lib/services/zip-code/zip-code.service.ts

@@ -1,20 +0,0 @@
-export class ZipCodeService {
-  /***
-   * Check valid zip code format
-   * @param code {string} - zip code string
-   * @return return true when correct
-   */
-  static isValid(code: string): boolean {
-    const re = new RegExp('^\\d\\d-\\d\\d\\d$');
-    return !!code.match(re);
-  }
-
-  /***
-   * Check invalid zip code format
-   * @param code {string} - zip code string
-   * @return return true when incorrect
-   */
-  static isInvalid(code: string): boolean {
-    return !ZipCodeService.isValid(code);
-  }
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}