@verisoft/core 18.6.0 → 18.7.0

package/.eslintrc.json

@@ -0,0 +1,43 @@
+{
+  "extends": ["../../../.eslintrc.base.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts"],
+      "extends": [
+        "plugin:@nx/angular",
+        "plugin:@angular-eslint/template/process-inline-templates"
+      ],
+      "rules": {
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "v",
+            "style": "camelCase"
+          }
+        ],
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": "element",
+            "prefix": "v",
+            "style": "kebab-case"
+          }
+        ]
+      }
+    },
+    {
+      "files": ["*.html"],
+      "extends": ["plugin:@nx/angular-template"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": "error"
+      }
+    }
+  ]
+}

package/README.md

@@ -1,7 +1,56 @@
 # core
 
-This library was generated with [Nx](https://nx.dev).
+The `core` library provides shared utilities, services, and base functionality for other libraries and applications in the Verisoft Frontend workspace.
 
-## Running unit tests
+## Features
 
-Run `nx test core` to execute the unit tests.
+- Common Angular services and utilities
+- Shared interfaces and types
+- Reusable logic for other libraries
+
+## Installation
+
+This package is intended for internal use within the monorepo. To use it in another library or app, add it as a dependency in your `project.json`:
+
+```json
+"dependencies": {
+  "core": "*"
+}
+```
+
+## Usage
+
+Import the required modules, services, or utilities from `core`:
+
+```typescript
+import { SomeService } from '@verisoft/core';
+```
+
+## Development
+
+### Building
+
+Run the following command to build the library:
+
+```sh
+nx build core
+```
+
+### Running Unit Tests
+
+To execute the unit tests for this library:
+
+```sh
+nx test core
+```
+
+## Contributing
+
+1. Fork the repository and create your branch from `master`.
+2. Make your changes and add tests if needed.
+3. Run `nx test core` to ensure all tests pass.
+4. Submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

package/jest.config.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+export default {
+  displayName: 'core',
+  preset: '../../../jest.preset.js',
+  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+  coverageDirectory: '../../../coverage/src/libs/core',
+  transform: {
+    '^.+\\.(ts|mjs|js|html)$': [
+      'jest-preset-angular',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+        stringifyContentPathRegex: '\\.(html|svg)$',
+      },
+    ],
+  },
+  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+  snapshotSerializers: [
+    'jest-preset-angular/build/serializers/no-ng-attributes',
+    'jest-preset-angular/build/serializers/ng-snapshot',
+    'jest-preset-angular/build/serializers/html-comment',
+  ],
+};

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/src/libs/core",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -1,29 +1,14 @@
-{
-  "name": "@verisoft/core",
-  "version": "18.6.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": {
-    "tslib": "^2.3.0"
-  },
-  "module": "fesm2022/verisoft-core.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/verisoft-core.mjs",
-      "esm": "./esm2022/verisoft-core.mjs",
-      "default": "./fesm2022/verisoft-core.mjs"
-    }
-  }
-}
+{
+  "name": "@verisoft/core",
+  "version": "18.7.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/project.json

@@ -0,0 +1,36 @@
+{
+  "name": "core",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "src/libs/core/src",
+  "prefix": "lib",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/angular:package",
+      "outputs": ["{workspaceRoot}/dist/{projectRoot}"],
+      "options": {
+        "project": "src/libs/core/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "src/libs/core/tsconfig.lib.prod.json"
+        },
+        "development": {
+          "tsConfig": "src/libs/core/tsconfig.lib.json"
+        }
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "src/libs/core/jest.config.ts"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

package/{index.d.ts → src/index.ts}

@@ -1,3 +1,3 @@
-export * from './lib/models';
-export * from './lib/services';
-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/{lib/models/all-item.datasource.d.ts → src/lib/models/all-item.datasource.ts}

@@ -1,4 +1,5 @@
-import { Observable } from 'rxjs';
-export interface AllItemDatasource<T> {
-    getData$: () => Observable<T[]>;
-}
+import { Observable } from 'rxjs';
+
+export interface AllItemDatasource<T> {
+  getData$: () => Observable<T[]>
+}

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/{lib/models/environment.model.d.ts → src/lib/models/environment.model.ts}

@@ -1,5 +1,5 @@
-export interface EnvironmentConfig {
-    production: boolean;
-    apiUrl: string;
-    appVersion: string;
-}
+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/{lib/models/event.models.d.ts → src/lib/models/event.models.ts}

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

package/{lib/models/index.d.ts → src/lib/models/index.ts}

@@ -1,7 +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';
+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

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { map, Observable } from 'rxjs';
+import {
+  AllDataRequestParams,
+  DEFAULT_SEARCH_PARAMS,
+  Page,
+  RequestParams,
+  requestParamsToHttpParams,
+} from '../models/base-http.models';
+import { LazyLoadEvent } from '../models/event.models';
+import { ClearUtils } from '../utils/clear.utils';
+
+export class BaseHttpService<T, TKey = number | string> {
+  constructor(
+    readonly http: HttpClient,
+    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.apiPath, { params }).pipe(
+      map((response: Page<T>) => {
+        response.limit = requestParams.limit;
+        return response;
+      })
+    );
+  }
+
+  getData$(
+    entityName: keyof T,
+    searchTerm?: string | undefined,
+    lazyLoad?: LazyLoadEvent
+  ): Observable<T[]> {
+    const filter: Partial<T> = { [entityName]: searchTerm } as Partial<T>;
+    const params = lazyLoad
+      ? requestParamsToHttpParams<T>({
+          ...DEFAULT_SEARCH_PARAMS,
+          offset: lazyLoad.offset,
+          limit: lazyLoad.limit,
+          filter,
+        })
+      : requestParamsToHttpParams<T>({
+          ...DEFAULT_SEARCH_PARAMS,
+          filter,
+        });
+
+    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);
+  }
+
+  put(id: TKey, entity: Partial<T>): Observable<T> {
+    const url = `${this.apiPath}/${id}`;
+    return this.http.put<T>(url, entity);
+  }
+
+  delete(id: TKey): Observable<T> {
+    const url = `${this.apiPath}/${id}`;
+    return this.http.delete<T>(url);
+  }
+
+  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.apiPath, {
+      body: entity,
+    });
+  }
+
+  createParams<T>(requestParams: RequestParams<T>): any {
+    const sorter = this.createSorter(requestParams);
+    const filter = JSON.parse(JSON.stringify(requestParams.filter));
+    const transformedFilter = filter;
+    ClearUtils.recursiveObjectAttributesDeletation(transformedFilter);
+    return {
+      paging: {
+        offset: requestParams.offset,
+        limit: requestParams.limit,
+      },
+      ...(sorter && { sorting: sorter }),
+      ...(transformedFilter && { filter: transformedFilter }),
+    };
+  }
+
+  private createSorter<T>(requestParams: RequestParams<T>) {
+    if (requestParams?.sort?.length === 1) {
+      const sorter = requestParams.sort[0];
+      return {
+        sortField: sorter.field,
+        sortOrder: sorter.direction,
+      };
+    }
+    return null;
+  }
+}

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/{lib/services/index.d.ts → src/lib/services/index.ts}

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