@verisoft/core 18.0.1-0 → 18.3.0

package/package.json

@@ -1,11 +1,14 @@
-{
-  "name": "@verisoft/core",
-  "version": "18.0.1-0",
-  "peerDependencies": {
-    "@angular/common": "^18.2.8",
-    "@angular/core": "^18.2.8",
-    "moment": "^2.30.1",
-    "rxjs": "~7.8.0"
-  },
-  "sideEffects": false
-}
+{
+  "name": "@verisoft/core",
+  "version": "18.3.0",
+  "peerDependencies": {
+    "@angular/common": "^18.2.8",
+    "@angular/core": "^18.2.8",
+    "moment": "^2.30.1",
+    "rxjs": "~7.8.0",
+    "@angular/forms": "18.2.8",
+    "@ngx-translate/core": "^15.0.0"
+  },
+  "sideEffects": false,
+  "dependencies": {}
+}

package/src/index.ts

@@ -1,7 +1,3 @@
-export * from './lib/base/models/base-http.models';
-export * from './lib/base/models/all-item.datasource';
-export * from './lib/models/lazy-load.model';
-
-export * from './lib/services/base-http.service';
-
-export * from './lib/utils';
+export * from './lib/models';
+export * from './lib/services';
+export * from './lib/utils';

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './models';

package/src/lib/models/base-http.models.ts

@@ -0,0 +1,144 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpParams, HttpResponse } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+
+export const BASE_URL_PATH = new InjectionToken<string>('BASE_URL_PATH');
+
+export function requestParamsToHttpParams<T>(
+  requestParams: Partial<RequestParams<T>>,
+  httpParams: HttpParams = new HttpParams()
+): HttpParams {
+  if (requestParams.limit != undefined) {
+    httpParams = httpParams.append('limit', requestParams.limit.toString());
+  }
+
+  if (requestParams.offset != undefined) {
+    httpParams = httpParams.append('offset', requestParams.offset.toString());
+  }
+
+  if (requestParams.id != '' && requestParams.id != undefined) {
+    httpParams = httpParams.append('id', requestParams.id as any);
+  }
+
+  httpParams = getFilter(requestParams, httpParams);
+  httpParams = getSort(requestParams, httpParams);
+
+  return httpParams;
+}
+
+function getFilter<T>(
+  requestParams: Partial<RequestParams<any>>,
+  httpParams: HttpParams
+): HttpParams {
+  if (!requestParams.filter) {
+    return httpParams;
+  }
+  Object.keys(requestParams?.filter).forEach((key) => {
+    const value = requestParams.filter?.[key as keyof Partial<T>];
+    if (value != undefined && !(typeof value === 'string' && value.trim() === "")) {
+      if (Array.isArray(value)) {
+        value.forEach((valueItem: any) => {
+          httpParams = httpParams.append(
+            'Filter.' + key, valueItem
+          );
+        });
+      } else {
+        httpParams = httpParams.append('Filter.' + key, value);
+      }
+    }
+  });
+  return httpParams;
+}
+
+function getSort(
+  requestParams: Partial<RequestParams<any>>,
+  httpParams: HttpParams
+): HttpParams {
+  if (!requestParams.sort) {
+    return httpParams;
+  }
+
+  requestParams.sort?.forEach((sort) => {
+    httpParams = httpParams
+      .append('Sort.Field', sort.field)
+      .append('Sort.Direction', sort.direction);
+  });
+  return httpParams;
+}
+
+export function saveFile(response: HttpResponse<Blob>) {
+  const fileName = response.headers
+    .get('Content-Disposition')
+    ?.split(';')[1]
+    .split('=')[1];
+  const blob: Blob = response.body as Blob;
+  const a = document.createElement('a');
+  a.download = fileName ?? 'undefined';
+  a.href = window.URL.createObjectURL(blob);
+  a.click();
+}
+
+export enum SortDirection {
+  asc = 'asc',
+  desc = 'desc',
+}
+
+export declare type SortDirectionType = keyof typeof SortDirection;
+
+export declare interface Sort {
+  field: string;
+  direction: SortDirectionType;
+}
+
+export interface RequestParams<T> extends AllDataRequestParams<T> {
+  offset: number;
+  limit: number;
+  id?: string;
+}
+
+export interface AllDataRequestParams<T> {
+  filter?: Partial<T>;
+  sort?: Sort[];
+}
+
+export interface Page<T> {
+  data: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+export interface CustomExport<T> {
+  sortDefinition?: Sort;
+  filter?: Partial<T>;
+  columnsToExport: ColumnExportSpecification[];
+}
+
+export interface ColumnExportSpecification {
+  name: string;
+  header: string;
+}
+
+export const DEFAULT_SEARCH_LIMIT = 50;
+
+export const DEFAULT_SEARCH_PARAMS: RequestParams<any> = {
+  offset: 0,
+  limit: DEFAULT_SEARCH_LIMIT,
+  id: '',
+};
+
+export function normalizeRequest<T>(
+  request: Partial<RequestParams<T>>,
+  minLimit: number | undefined = undefined
+): RequestParams<T> {
+  return {
+    offset: request?.offset ?? 0,
+    limit: !request?.limit
+      ? DEFAULT_SEARCH_LIMIT
+      : minLimit && request.limit < minLimit
+      ? minLimit
+      : request.limit,
+    filter: request?.filter,
+    sort: request?.sort,
+  };
+}

package/src/lib/models/constants.ts

@@ -0,0 +1,8 @@
+import { LazyLoadEvent } from './event.models';
+
+export const DEFAULT_PAGE_SIZE = 50;
+
+export const DEFAULT_LAZYLOAD_OPTIONS: LazyLoadEvent = {
+  offset: 0,
+  limit: DEFAULT_PAGE_SIZE,
+};

package/src/lib/models/datasource.model.ts

@@ -0,0 +1,77 @@
+import { HttpClient } from '@angular/common/http';
+import { isObservable, map, Observable, of } from 'rxjs';
+import { BaseHttpService } from '../services/base-http.service';
+import { AllItemDatasource } from './all-item.datasource';
+import { Page, RequestParams } from './base-http.models';
+import { DEFAULT_PAGE_SIZE } from './constants';
+
+export type DatasourceType<T> =
+  | string
+  | Observable<T[]>
+  | Observable<Page<T>>
+  | BaseHttpService<T>
+  | T[]
+  | Page<T>
+  | AllItemDatasource<T>;
+
+export type DataSourceFunctionType<T> = (
+  requestParams: RequestParams<T>
+) => Observable<Page<T>>;
+
+export function convertDatasource<T>(
+  datasource: DatasourceType<T>,
+  basePath: string,
+  httpClient: HttpClient
+): DataSourceFunctionType<T> {
+  if (!datasource) {
+    throw new Error('Datasource is not defined');
+  }
+
+  if (typeof datasource === 'string') {
+    const service = new BaseHttpService<T>(httpClient, basePath, datasource);
+    return (requestParams: RequestParams<T>) =>
+      service.fetchList(requestParams);
+  }
+
+  if (datasource instanceof BaseHttpService) {
+    return (requestParams: RequestParams<T>) =>
+      datasource.fetchList(requestParams);
+  }
+
+  if (isObservable(datasource)) {
+    return () =>
+      (datasource as Observable<Page<T> | T[]>).pipe(map(convertArrayToPage));
+  }
+
+  const allItemDatasource = <AllItemDatasource<T>>datasource;
+  if (allItemDatasource.getData$) {
+    return () =>
+      allItemDatasource
+        .getData$()
+        .pipe(map((data) => convertArrayToPage(data)));
+  }
+
+  const page = <Page<T>>datasource;
+  if (page.data) {
+    return () => of(page);
+  }
+
+  if (Array.isArray(datasource)) {
+    return () => of(convertArrayToPage(datasource));
+  }
+
+  throw new Error('Datasource is not supported');
+}
+
+function convertArrayToPage<T>(data: Page<T> | T[]): Page<T> {
+  if (Array.isArray(data)) {
+    return {
+      data: data ?? [],
+      total: data?.length ?? 0,
+      limit: data?.length ?? DEFAULT_PAGE_SIZE,
+      offset: 0,
+    };
+  }
+
+  return data as Page<T>;
+}

package/src/lib/models/environment.model.ts

@@ -0,0 +1,5 @@
+export interface EnvironmentConfig {
+    production: boolean;
+    apiUrl: string;
+    appVersion: string;
+}

package/src/lib/models/error-provider.model.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { ValidationErrors } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+export interface ErrorProvider {
+  mapError(errors: ValidationErrors): Observable<string>;
+  errors: Record<string, (value?: any) => string>;
+}
+
+export const ERROR_PROVIDER_TOKEN
+  = new InjectionToken<ErrorProvider>('ERROR_PROVIDER_TOKEN');
+
+export enum CustomValidationCodes {}
+
+export const ErrorMap: Record<string, (value?: any) => string> = {
+  required: () => `VALIDATIONS.REQUIRED`,
+  email: () => `VALIDATIONS.EMAIL`,
+  minLength: () => 'VALIDATIONS.MIN_LENGTH',
+  maxLength: () => 'VALIDATIONS.MAX_LENGTH',
+};

package/src/lib/models/event.models.ts

@@ -0,0 +1,7 @@
+import { RequestParams } from "./base-http.models";
+
+export type LazyLoadEvent = RequestParams<unknown>;
+
+export interface FilterEvent {
+    filter?: string;
+}

package/src/lib/models/index.ts

@@ -0,0 +1,7 @@
+export * from './environment.model';
+export * from './event.models';
+export * from './constants';
+export * from './base-http.models';
+export * from './all-item.datasource';
+export * from './datasource.model';
+export * from './error-provider.model';

package/src/lib/services/base-http.service.ts

@@ -1,50 +1,50 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { HttpClient } from '@angular/common/http';
-import { Inject, Injectable } from '@angular/core';
 import { map, Observable } from 'rxjs';
 import {
-  BASE_URL_PATH,
+  AllDataRequestParams,
+  DEFAULT_SEARCH_PARAMS,
   Page,
   RequestParams,
   requestParamsToHttpParams,
-} from '../base/models/base-http.models';
-import { DEFAULT_SEARCH_PARAMS } from '../base/models/table-datasource.models';
-import { LazyLoad } from '../models/lazy-load.model';
+} from '../models/base-http.models';
+import { LazyLoadEvent } from '../models/event.models';
 import { ClearUtils } from '../utils/clear.utils';
 
-@Injectable({ providedIn: 'root' })
-export abstract class BaseHttpService<T, TKey = number> {
-  basePath = '';
-  entityName!: string;
+export class BaseHttpService<T, TKey = number | string> {
   constructor(
     readonly http: HttpClient,
-    @Inject(BASE_URL_PATH) basePath: string
+    readonly basePath: string,
+    readonly entityName: string
   ) {
     this.basePath = basePath;
   }
+
+  protected get apiPath() {
+    return this.basePath ? this.basePath + this.entityName : this.entityName;
+  }
+
   fetchList(requestParams: RequestParams<T>): Observable<Page<T>> {
     const params = requestParamsToHttpParams<T>(requestParams);
-    return this.http
-      .get<Page<T>>(this.basePath + this.entityName, { params })
-      .pipe(
-        map((response: Page<T>) => {
-          response.size = requestParams.size;
-          return response;
-        })
-      );
+    return this.http.get<Page<T>>(this.apiPath, { params }).pipe(
+      map((response: Page<T>) => {
+        response.limit = requestParams.limit;
+        return response;
+      })
+    );
   }
 
   getData$(
     entityName: keyof T,
     searchTerm?: string | undefined,
-    lazyLoad?: LazyLoad
+    lazyLoad?: LazyLoadEvent
   ): Observable<T[]> {
     const filter: Partial<T> = { [entityName]: searchTerm } as Partial<T>;
     const params = lazyLoad
       ? requestParamsToHttpParams<T>({
           ...DEFAULT_SEARCH_PARAMS,
-          page: Math.round(lazyLoad.offset / lazyLoad.limit),
-          size: lazyLoad.limit,
+          offset: lazyLoad.offset,
+          limit: lazyLoad.limit,
           filter,
         })
       : requestParamsToHttpParams<T>({
@@ -52,26 +52,36 @@ export abstract class BaseHttpService<T, TKey = number> {
           filter,
         });
 
-    return this.http.get<T[]>(this.basePath + this.entityName, { params });
+    return this.http.get<T[]>(this.apiPath, { params });
+  }
+
+  get(id: TKey): Observable<T> {
+    const url = `${this.apiPath}/${id}`;
+    return this.http.get<T>(url);
+  }
+
+  post(entity: Partial<T>): Observable<T> {
+    return this.http.post<T>(this.apiPath, entity);
   }
 
-  get(id: TKey, url?: string): Observable<T> {
-    const newUrl = url ? `/${url}/${id}` : `/${id}`;
-    return this.http.get<T>(newUrl);
+  put(id: TKey, entity: Partial<T>): Observable<T> {
+    const url = `${this.apiPath}/${id}`;
+    return this.http.put<T>(url, entity);
   }
 
-  post(entity: Partial<T>, url?: string): Observable<T> {
-    const newUrl = url ? this.basePath + `/${url}` : this.basePath;
-    return this.http.post<T>(newUrl, entity);
+  delete(id: TKey): Observable<T> {
+    const url = `${this.apiPath}/${id}`;
+    return this.http.delete<T>(url);
   }
 
-  put(id: TKey, entity: Partial<T>, url?: string): Observable<T> {
-    const newUrl = this.basePath + (url ? `/${url}/${id}` : `/${id}`);
-    return this.http.put<T>(newUrl, entity);
+  export(requestParams: AllDataRequestParams<T>): Observable<Blob> {
+    const httpParams = requestParamsToHttpParams<T>(requestParams);
+    const url = `${this.apiPath}/export`;
+    return this.http.get(url, { responseType: 'blob', params: httpParams });
   }
 
   removeRange(entity: string[]) {
-    return this.http.delete(this.basePath + this.entityName, {
+    return this.http.delete(this.apiPath, {
       body: entity,
     });
   }
@@ -83,8 +93,8 @@ export abstract class BaseHttpService<T, TKey = number> {
     ClearUtils.recursiveObjectAttributesDeletation(transformedFilter);
     return {
       paging: {
-        page: requestParams.page,
-        size: requestParams.size,
+        offset: requestParams.offset,
+        limit: requestParams.limit,
       },
       ...(sorter && { sorting: sorter }),
       ...(transformedFilter && { filter: transformedFilter }),

package/src/lib/services/error-provider.service.ts

@@ -0,0 +1,29 @@
+import { inject, Injectable } from '@angular/core';
+import { ValidationErrors } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ErrorProvider, ErrorMap } from '../models/error-provider.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LocalizableErrorProviderService implements ErrorProvider {
+  private readonly translateService = inject(TranslateService);
+  readonly errors: Record<string, (value?: any) => string> = ErrorMap;
+
+  mapError(errors: ValidationErrors): Observable<string> {
+    const error = this.getFirstValue(errors);
+    try {
+      const value = this.errors[error.key](error.value);
+      return this.translateService.get(value);
+    } catch (_) {
+      throw new Error(`Key "${error.key}" is not specified in the current error map!`);
+    }
+  }
+
+  private getFirstValue(errors: ValidationErrors): { key: string; value: string } {
+    const key = Object.keys(errors)[0];
+    const value = errors[key];
+    return { key, value };
+  }
+}

package/src/lib/services/index.ts

@@ -0,0 +1,3 @@
+export * from './base-http.service';
+export * from './local-storage.service';
+export * from './error-provider.service'

package/src/lib/services/local-storage.service.ts

@@ -0,0 +1,13 @@
+export class LocalStorageService {
+    setItem(key: string, value: string) {
+        localStorage.setItem(key, value);
+    }
+
+    getItem(key: string): string | null {
+        return localStorage.getItem(key);
+    }
+
+    removeItem(key: string) {
+        localStorage.removeItem(key);
+    }
+}

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

@@ -0,0 +1,13 @@
+export class StorageService {
+    setItem(key: string, value: string) {
+        localStorage.setItem(key, value);
+    }
+
+    getItem(key: string): string | null {
+        return localStorage.getItem(key);
+    }
+
+    removeItem(key: string) {
+        localStorage.removeItem(key);
+    }
+}

package/src/lib/utils/array.utils.spec.ts

@@ -0,0 +1,49 @@
+import { applyFilter } from './array.utils';
+describe('array.utils', () => {
+  describe('applyFilter', () => {
+    interface TestData {
+      id: number;
+      name: string;
+      tags: string[];
+      age: number;
+    }
+
+    const data: TestData[] = [
+      { id: 1, name: 'Alice', tags: ['developer', 'angular'], age: 25 },
+      { id: 2, name: 'Bob', tags: ['designer', 'figma'], age: 30 },
+      { id: 3, name: 'Charlie', tags: ['developer'], age: 25 },
+      { id: 4, name: 'Dave', tags: ['developer', 'react'], age: 35 },
+    ];
+
+    const [alice, , charlie] = data;
+
+    test('Should filter data by contains string value when a single string filter is applied', () => {
+      const filter = { name: 'lice' };
+      const result = applyFilter(data, filter);
+      expect(result).toEqual([alice]);
+    });
+
+    test('Should filter data when filter contains an array value', () => {
+      const filter = { tags: ['develop'] };
+      const result = applyFilter(data, filter);
+      expect(result).toHaveLength(3);
+    });
+
+    test('Should filter data with multiple conditions when filter properties use AND logic', () => {
+      const filter = { age: 25, tags: ['developer'] };
+      const result = applyFilter(data, filter);
+      expect(result).toEqual([alice, charlie]);
+    });
+
+    test('Should return all data when the filter is empty', () => {
+      const result = applyFilter(data, {});
+      expect(result).toEqual(data);
+    });
+
+    test('Should return no data when no items match the filter', () => {
+      const filter = { name: 'Zoe' };
+      const result = applyFilter(data, filter);
+      expect(result).toHaveLength(0);
+    });
+  });
+});

package/src/lib/utils/array.utils.ts

@@ -1,3 +1,6 @@
+import { Sort } from "../models";
+import { getValueByPath } from "./object.utils";
+
 type ArrayIntersectionType = (string | number)[]
 
 export function isArrayIntersected(
@@ -7,3 +10,45 @@ export function isArrayIntersected(
   const filteredArray = array1.filter(value => array2.includes(value));
   return filteredArray.length > 0;
 }
+
+export function multiSort<T>(values: T[], sorts: Sort[]): T[] {
+  return [...values].sort((a, b) => {
+    for (const sort of sorts) {
+      const { field, direction } = sort;
+      const valueA = getValueByPath(a, field);
+      const valueB = getValueByPath(b, field);
+
+      if (valueA !== valueB) {
+        if (isComparable(valueA) && isComparable(valueB)) {
+          if (typeof valueA === 'string' && typeof valueB === 'string') {
+            const baseCompare = valueA.localeCompare(valueB, undefined, {
+              sensitivity: 'base',
+            });
+
+            if (baseCompare === 0) {
+              return valueA < valueB ? -1 : valueA > valueB ? 1 : 0;
+            }
+
+            return direction === 'asc' ? baseCompare : -baseCompare;
+          } else {
+            if (valueA < valueB) {
+              return direction === 'asc' ? -1 : 1;
+            }
+            if (valueA > valueB) {
+              return direction === 'asc' ? 1 : -1;
+            }
+          }
+        }
+      }
+    }
+
+    return 0;
+  });
+}
+
+function isComparable(value: unknown): value is string | number | Date {
+  return typeof value === 'string'
+    || typeof value === 'number'
+    || typeof value === 'boolean'
+    || value instanceof Date;
+}

package/src/lib/utils/data.utils.ts

@@ -1,6 +1,6 @@
 import moment from 'moment';
 
-export function transformData(data: any){
+export function transformData(data: any) {
   if (data) {
     if (moment.isMoment(data)) {
       return moment(data)
@@ -14,7 +14,7 @@ export function transformData(data: any){
   return data;
 }
 
-export function convertToDate(data: any){
+export function convertToDate(data: any) {
   if (data) {
     if (!isNaN(Date.parse(data))) {
       return new Date(data);
@@ -23,7 +23,7 @@ export function convertToDate(data: any){
   return data;
 }
 
-export function convertToDateTime(data: any){
+export function convertToDateTime(data: any) {
   if (data) {
     if (!isNaN(Date.parse(data))) {
       const date = new Date(data);
@@ -31,4 +31,4 @@ export function convertToDateTime(data: any){
     }
   }
   return data;
-}
+}

package/src/lib/utils/date.utils.ts

@@ -0,0 +1,30 @@
+const czechDateFormat = new Intl.DateTimeFormat("cs-CZ", {
+  day: "numeric",
+  month: "numeric",
+  year: "numeric"
+});
+
+const czechDateTimeFormat = new Intl.DateTimeFormat("cs-CZ", {
+  second: "numeric",
+  minute: "numeric",
+  hour: "numeric",
+  day: "numeric",
+  month: "numeric",
+  year: "numeric"
+});
+
+export function toCzechDateTimeString(value?: Date | string, time = false): string {
+  if (!value) {
+    return "";
+  }
+
+  if (typeof value === "string") {
+    value = new Date(value);
+  }
+
+  if (time) {
+    return czechDateTimeFormat.format(value);
+  }
+
+  return czechDateFormat.format(value);
+}

package/src/lib/utils/index.ts

@@ -3,3 +3,4 @@ export * from './keyOrFn.utils';
 export * from './array.utils';
 export * from './data.utils';
 export * from './object.utils';
+export * from './date.utils';

package/src/lib/utils/keyOrFn.utils.ts

@@ -1,10 +1,10 @@
-export function keyOrFn(keyOrFn: ((row: any) => string | undefined) | string, row: any){
+export function keyOrFn(keyOrFn: ((row: any) => string | undefined) | string, row: any) {
     if (keyOrFn instanceof Function) {
         return keyOrFn(row);
     }
     else if (typeof keyOrFn === 'string') {
         const value = row[keyOrFn];
-        if (value){
+        if (value) {
             return value;
         }
     }

package/src/lib/utils/object.utils.spec.ts

@@ -1,4 +1,4 @@
-import { sortBy } from './object.utils';
+import { getValueByPath, sortBy } from './object.utils';
 
 describe('object.utils', () => {
   describe('sortBy', () => {
@@ -31,4 +31,39 @@ describe('object.utils', () => {
       expect(sortedItems?.[3].name).toBeUndefined();
     });
   });
+
+  describe('getValueByPath', () => {
+    const complexObject = {
+      name: 'Martin',
+      age: 40,
+      address: {
+        city: 'Brno',
+        street: 'Kralova',
+      },
+    };
+
+    test('Should return property value when name of property is provided.', () => {
+      const value = getValueByPath(complexObject, 'name');
+
+      expect(value).toBe('Martin');
+    });
+
+    test('Should return undefined when name is nonexistent.', () => {
+      const value = getValueByPath(complexObject, 'nonexistentProperty');
+
+      expect(value).toBeUndefined();
+    });
+
+    test('Should return property value when name of property is complex path.', () => {
+      const value = getValueByPath(complexObject, 'address.city');
+
+      expect(value).toBe('Brno');
+    });
+
+    test('Should return undefined when some object on complex path missing.', () => {
+      const value = getValueByPath(complexObject, 'car.model');
+
+      expect(value).toBeUndefined();
+    });
+  });
 });

package/src/lib/utils/object.utils.ts

@@ -29,3 +29,19 @@ export function sortBy<TEntity, TProperty>(
     return 0;
   });
 }
+
+export function getValueByPath<T, TValue>(
+  obj: T,
+  path: string | undefined,
+): TValue | undefined {
+  if (path == undefined || path == ''){
+    return obj as unknown as TValue;
+  }
+
+  return path.split('.').reduce((acc, key) => {
+    if (acc && typeof acc === 'object' && key in acc) {
+      return (acc as Record<string, TValue>)[key];
+    }
+    return undefined;
+  }, obj as unknown) as TValue;
+}

package/src/lib/base/models/base-http.models.ts

@@ -1,96 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { HttpParams, HttpResponse } from '@angular/common/http';
-import { InjectionToken } from '@angular/core';
-
-export const BASE_URL_PATH = new InjectionToken("BASE_URL_PATH");
-
-export function requestParamsToHttpParams<T>(
-  requestParams: RequestParams<T>,
-  httpParams: HttpParams = new HttpParams()
-): HttpParams {
-  httpParams = httpParams
-    .append('Limit', requestParams.size.toString())
-    .append('Offset', (requestParams.page * requestParams.size).toString());
-  if (requestParams.id != '' && requestParams.id != undefined) {
-    httpParams = httpParams.append('Id', requestParams.id as any);
-  }
-
-  httpParams = getFilter(requestParams, httpParams);
-  httpParams = getSort(requestParams, httpParams);
-
-  return httpParams;
-}
-
-function getFilter<T>(
-  requestParams: RequestParams<any>,
-  httpParams: HttpParams
-): HttpParams {
-  if (!requestParams.filter) {
-    return httpParams;
-  }
-  Object.keys(requestParams?.filter).forEach((key) => {
-    if (requestParams.filter?.[key as keyof Partial<T>]) {
-      httpParams = httpParams.append(
-        'Filter.' + key,
-        requestParams.filter?.[key as keyof Partial<T>]
-      );
-    }
-  });
-  return httpParams;
-}
-
-function getSort(
-  requestParams: RequestParams<any>,
-  httpParams: HttpParams
-): HttpParams {
-  if (!requestParams.sort) {
-    return httpParams;
-  }
-
-  requestParams.sort?.forEach((sort) => {
-    httpParams = httpParams
-      .append('Sort.Field', sort.field)
-      .append('Sort.Direction', sort.direction === -1 ? 'Desc' : 'Asc');
-  });
-  return httpParams;
-}
-
-export function saveFile(response: HttpResponse<Blob>) {
-  const fileName = response.headers
-    .get('Content-Disposition')
-    ?.split(';')[1]
-    .split('=')[1];
-  const blob: Blob = response.body as Blob;
-  const a = document.createElement('a');
-  a.download = fileName ?? 'undefined';
-  a.href = window.URL.createObjectURL(blob);
-  a.click();
-}
-
-export declare interface Sort<T> {
-  field: string;
-  direction: number;
-}
-
-export interface RequestParams<T> {
-  page: number;
-  size: number;
-  id?: string;
-  filter?: Partial<T>;
-  sort?: Sort<T>[];
-}
-
-export interface Page<T> {
-  data: T[];
-  total: number;
-  size: number;
-  number: number;
-}
-
-export const DEFAULT_SEARCH_LIMIT = 50;
-
-export const DEFAULT_SEARCH_PARAMS: RequestParams<any> = {
-  page: 0,
-  size: DEFAULT_SEARCH_LIMIT,
-  id: '',
-};

package/src/lib/base/models/table-datasource.models.ts

@@ -1,9 +0,0 @@
-import { RequestParams } from "./base-http.models";
-
-export const DEFAULT_SEARCH_LIMIT = 50;
-
-export const DEFAULT_SEARCH_PARAMS: RequestParams<any> = {
-  page: 0,
-  size: DEFAULT_SEARCH_LIMIT,
-  id: '',
-};

package/src/lib/models/lazy-load.model.ts

@@ -1,4 +0,0 @@
-export interface LazyLoad {
-    offset: number;
-    limit: number;
-}