@mosa-ng/core 17.0.0

package/src/lib/pipes/find-in-array/find-in-array.pipe.ts

@@ -0,0 +1,34 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+    name: 'findInArray',
+})
+export class FindInArrayPipe implements PipeTransform {
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public transform<T>(searchValue: any, array: T[], searchKey: keyof T, returnElements?: (keyof T)[]): any {
+        // Return if array is empty or null
+        if (!array || !array.length) {
+            return null;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const foundItem: T = array.find((val: T): boolean => (searchKey ? val[ searchKey as keyof T ] : val) === searchValue);
+        if (!foundItem) {
+            return null;
+        }
+
+        // Return whole item
+        if (!returnElements) {
+            return foundItem;
+        }
+
+        if (returnElements.length === 1) {
+            return foundItem[ returnElements[ 0 ] ];
+        }
+
+        // Return given values to the keys
+        return returnElements.map((val: keyof T) => foundItem[ val as keyof T ]);
+    }
+
+}

package/src/lib/pipes/join/join-pipe.module.ts

@@ -0,0 +1,17 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { JoinPipe } from './join.pipe';
+
+
+@NgModule({
+    declarations: [
+        JoinPipe,
+    ],
+    exports: [
+        JoinPipe,
+    ],
+    imports: [
+        CommonModule,
+    ],
+})
+export class JoinPipeModule { }

package/src/lib/pipes/join/join.pipe.spec.ts

@@ -0,0 +1,8 @@
+import { JoinPipe } from './join.pipe';
+
+describe('JoinPipe', (): void => {
+    it('create an instance', (): void => {
+        const pipe: JoinPipe = new JoinPipe();
+        void expect(pipe).toBeTruthy();
+    });
+});

package/src/lib/pipes/join/join.pipe.ts

@@ -0,0 +1,20 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+    name: 'join',
+})
+export class JoinPipe implements PipeTransform {
+
+    /**
+     * Join array by separator
+     * @param array
+     * @param returnField
+     * @param separator
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public transform(array: any[], returnField: any, separator: string = ', '): string {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return array.map((val: any): string => returnField ? val[ returnField ] : val).join(separator);
+    }
+
+}

package/src/lib/pipes/mosa-date-pipe/mosa-date-pipe.module.ts

@@ -0,0 +1,14 @@
+import { CommonModule, DatePipe } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MosaDatePipe } from './mosa-date.pipe';
+
+@NgModule({
+    declarations: [ MosaDatePipe ],
+    imports: [
+        CommonModule,
+    ],
+    exports: [ MosaDatePipe ],
+    providers: [ DatePipe ],
+})
+export class MosaDatePipeModule {
+}

package/src/lib/pipes/mosa-date-pipe/mosa-date.pipe.ts

@@ -0,0 +1,102 @@
+import { DatePipe } from '@angular/common';
+import { Pipe, PipeTransform } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+@Pipe({
+    name: 'mosaDate',
+})
+export class MosaDatePipe implements PipeTransform {
+
+    private readonly store$: BehaviorSubject<number>;
+    private templates: Record<string, string>;
+
+    constructor(
+        private readonly myTranslateService: TranslateService,
+        private readonly myDatePipe: DatePipe,
+    ) {
+        this.store$ = new BehaviorSubject<number>(null);
+        this.updateTemplates();
+        setInterval((): void => {
+            this.store$.next(new Date().getTime());
+        }, 10);
+        this.myTranslateService.onLangChange.subscribe((): void => {
+            this.updateTemplates();
+            this.store$.next(new Date().getTime());
+        });
+    }
+
+    public transform(date: string | Date, mode: 'full' | 'timeSince' | 'date' = 'timeSince'): Observable<string> {
+        return this.store$.pipe(map((currentDate: number): string => this.calcDate(currentDate, date, mode)));
+    }
+
+    private calcDate(currentDate: number, date: string | Date, mode: 'full' | 'timeSince' | 'date'): string {
+        let parsed: number;
+        if (date instanceof Date) {
+            parsed = new Date(date.toString()).getTime();
+        } else {
+            parsed = new Date(date).getTime();
+        }
+
+        if (!currentDate) {
+            currentDate = new Date().getTime();
+        }
+
+        const convertedDate = this.myDatePipe.transform(parsed, 'dd. MMM. yyyy hh:mm aaa');
+        if (mode === 'full' || mode === 'timeSince') {
+            const seconds = ((currentDate - parsed) * .001) >> 0;
+            const minutes = seconds / 60;
+            const hours = minutes / 60;
+            const days = hours / 24;
+            const years = days / 365;
+
+            const timeSince: string = this.templates[ 'prefix' ] + (
+                seconds < 60 && this.template('seconds', seconds) ||
+                seconds < 120 && this.template('minute', 1) ||
+                minutes < 60 && this.template('minutes', minutes) ||
+                minutes < 120 && this.template('hour', 1) ||
+                hours < 24 && this.template('hours', hours) ||
+                hours < 42 && this.template('day', 1) ||
+                days < 30 && this.template('days', days) ||
+                days < 45 && this.template('month', 1) ||
+                days < 365 && this.template('months', days / 30) ||
+                years < 1.5 && this.template('year', 1) ||
+                this.template('years', years)
+            ) + this.templates[ 'prefix' ];
+
+            if (mode === 'timeSince') {
+                return timeSince;
+            }
+
+            if (mode === 'full') {
+                return `${convertedDate} (${timeSince})`;
+            }
+        }
+
+        return convertedDate;
+    }
+
+    private template(key: string, val: number): string {
+        return this.templates[ key ] && this.templates[ key ].replace(/%d/i, String(Math.abs(Math.round(val))));
+    }
+
+    private updateTemplates(): void {
+        this.templates = {
+            prefix: this.myTranslateService.instant('mosa.pipes.timeSince.prefix'),
+            suffix: this.myTranslateService.instant('mosa.pipes.timeSince.suffix'),
+            seconds: this.myTranslateService.instant('mosa.pipes.timeSince.seconds'),
+            minute: this.myTranslateService.instant('mosa.pipes.timeSince.minute'),
+            minutes: this.myTranslateService.instant('mosa.pipes.timeSince.minutes'),
+            hour: this.myTranslateService.instant('mosa.pipes.timeSince.hour'),
+            hours: this.myTranslateService.instant('mosa.pipes.timeSince.hours'),
+            day: this.myTranslateService.instant('mosa.pipes.timeSince.day'),
+            days: this.myTranslateService.instant('mosa.pipes.timeSince.days'),
+            month: this.myTranslateService.instant('mosa.pipes.timeSince.month'),
+            months: this.myTranslateService.instant('mosa.pipes.timeSince.months'),
+            year: this.myTranslateService.instant('mosa.pipes.timeSince.year'),
+            years: this.myTranslateService.instant('mosa.pipes.timeSince.years'),
+        };
+    }
+
+}

package/src/lib/pipes/mosa-duration-pipe/mosa-duration-pipe.module.ts

@@ -0,0 +1,13 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MosaDurationPipe } from './mosa-duration.pipe';
+
+@NgModule({
+    declarations: [ MosaDurationPipe ],
+    imports: [
+        CommonModule,
+    ],
+    exports: [ MosaDurationPipe ],
+})
+export class MosaDurationPipeModule {
+}

package/src/lib/pipes/mosa-duration-pipe/mosa-duration.pipe.ts

@@ -0,0 +1,106 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { MosaDurationFormat } from '../../models/mosa-duration.model';
+
+@Pipe({
+    name: 'mosaDuration',
+})
+export class MosaDurationPipe implements PipeTransform {
+
+    private readonly store$: BehaviorSubject<number>;
+    private readonly interval: NodeJS.Timeout;
+
+    constructor(
+        private readonly myTranslateService: TranslateService,
+    ) {
+        this.store$ = new BehaviorSubject<number>(new Date().getTime());
+        this.interval = setInterval(() => {
+            this.store$.next(new Date().getTime());
+        }, 1000);
+        this.myTranslateService.onLangChange.subscribe((): void => {
+            this.store$.next(new Date().getTime());
+        });
+    }
+
+    /**
+     * Converts a timestamp to a duration in the given format
+     * @param millis
+     * @param format
+     * @returns
+     * auto: 15000 -> 15 seconds
+     * seconds: 15000 -> 15 seconds
+     * minutes: 60000 -> 1 minute
+     * hours: 7200000 -> 2 hours
+     * days: 172800000 -> 2 days
+     */
+    public transform(millis: number, format: MosaDurationFormat = 'auto'): Observable<string> {
+        return this.store$.pipe(
+            map((currentDate: number): string => {
+                if (!millis) {
+                    clearInterval(this.interval);
+                    return null;
+                }
+
+                if (millis - currentDate < 0) {
+                    clearInterval(this.interval);
+                    return null;
+                }
+
+                return this.calcDuration(currentDate, millis, format);
+            }),
+        );
+    }
+
+
+    private getTranslation(num: number, format: MosaDurationFormat): string {
+        if (num === 1) {
+            return `${ num.toFixed(0) } ${ this.myTranslateService.instant(`mosa.commons.dateTime[${ format }].label`) }`;
+        }
+        return `${ num.toFixed(0) } ${ this.myTranslateService.instant(`mosa.commons.dateTime[${ format }].plural.label`) }`;
+    }
+
+
+    private calcDuration(currentDate: number, millis: number, format: MosaDurationFormat): string {
+        millis = millis - currentDate;
+
+        const seconds: number = millis / 1000;
+        if (format === 'seconds') {
+            return this.getTranslation(seconds, 'seconds');
+        }
+
+        const minutes: number = seconds / 60;
+        if (format === 'minutes') {
+            return this.getTranslation(minutes, 'minutes');
+        }
+
+        const hours: number = minutes / 60;
+        if (format === 'hours') {
+            return this.getTranslation(hours, 'hours');
+        }
+
+        const days: number = hours / 24;
+        if (format === 'days') {
+            return this.getTranslation(days, 'days');
+        }
+
+        if (format === 'auto') {
+            if (seconds < 60) {
+                return this.getTranslation(seconds, 'seconds');
+            }
+
+            if (minutes < 60) {
+                return this.getTranslation(minutes, 'minutes');
+            }
+
+            if (hours < 24) {
+                return this.getTranslation(hours, 'hours');
+            }
+
+            return this.getTranslation(days, 'days');
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,270 @@
+import { HttpClient, HttpErrorResponse, HttpEvent, HttpHeaders, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { IApiOptions } from '../models/api-options.model';
+import { ITokenSettings } from '../models/token-settings.model';
+import { CoreLoggerService } from './core-logger.service';
+import { isNullOrEmpty } from '../utils/commons.util';
+
+export const LOCAL_STORAGE_TOKEN_KEY = 'tokenSettings';
+
+@Injectable({
+    providedIn: 'root',
+})
+export class ApiService {
+
+    constructor(
+        private readonly myCoreLoggerService: CoreLoggerService,
+        private readonly myHttpClient: HttpClient,
+    ) {
+    }
+
+    /**
+     * Gets an access token
+     * @deprecated use getToken()
+     */
+    public getAccessToken(): string {
+        return window.localStorage.getItem('jwtAccessToken');
+    }
+
+    /**
+     * Sets an access token
+     * @param token
+     * @deprecated use setToken()
+     */
+    public setAccessToken(token: string): void {
+        window.localStorage.setItem('jwtAccessToken', token);
+    }
+
+    /**
+     * Removes an access token from local storage
+     * @deprecated use deleteAccessToken()
+     */
+    public removeAccessToken(): void {
+        window.localStorage.removeItem('jwtAccessToken');
+    }
+
+    /**
+     * Sets the token
+     * @param tokenSettings
+     */
+    public setToken(tokenSettings: ITokenSettings): void {
+        window.localStorage.setItem(LOCAL_STORAGE_TOKEN_KEY, JSON.stringify(tokenSettings));
+    }
+
+    /**
+     * Gets token
+     */
+    public getToken(): ITokenSettings {
+        const tokenSettings: string = window.localStorage.getItem(LOCAL_STORAGE_TOKEN_KEY);
+        if (isNullOrEmpty(tokenSettings)) {
+            return null;
+        }
+
+        return JSON.parse(tokenSettings);
+    }
+
+    /**
+     * Deletes token
+     */
+    public deleteToken(): void {
+        window.localStorage.removeItem(LOCAL_STORAGE_TOKEN_KEY);
+    }
+
+    /**
+     * Makes an http get call
+     * @param url
+     * @param headers
+     * @param options
+     */
+    public get<T>(url: string, headers?: HttpHeaders, options?: IApiOptions): Observable<T> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.get<T>(url, { ...options.httpOptions as any, headers })
+            .pipe(
+                map((response: HttpEvent<T>) => this.handleResponse(response)),
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * Makes an async http get call, which also includes the response headers
+     * @param url
+     * @param headers
+     * @param options
+     */
+    public async getWithHeadersAsync<T>(url: string, headers?: HttpHeaders, options?: IApiOptions): Promise<HttpEvent<T>> {
+        return this.getWithHeaders<T>(url, headers, options).toPromise();
+    }
+
+    /**
+     * Makes an http get call, which also includes the response headers
+     * @param url
+     * @param headers
+     * @param options
+     */
+    public getWithHeaders<T>(url: string, headers?: HttpHeaders, options?: IApiOptions): Observable<HttpEvent<T>> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.get<T>(url, { ...options.httpOptions as any, headers, observe: 'response' })
+            .pipe(
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * Makes an http patch call (For partial updates)
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    public patch<T, T1>(url: string, data?: T, headers?: HttpHeaders, options?: IApiOptions): Observable<T1> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.patch<T1>(url, data, { ...options.httpOptions as any, headers })
+            .pipe(
+                map((response: HttpEvent<T1>) => this.handleResponse(response)),
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * Makes an http put call
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    public put<T, T1>(url: string, data?: T, headers?: HttpHeaders, options?: IApiOptions): Observable<T1> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.put<T1>(url, data, { ...options.httpOptions as any, headers })
+            .pipe(
+                map((response: HttpEvent<T1>) => this.handleResponse(response)),
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * Makes an http post call
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    public post<T, T1>(url: string, data?: T, headers?: HttpHeaders, options?: IApiOptions): Observable<T1> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.post<T1>(url, data, { ...options.httpOptions as any, headers })
+            .pipe(
+                map((response: HttpEvent<T1>) => this.handleResponse(response)),
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * makes an http delete call
+     * @param url
+     * @param headers
+     * @param options
+     * @returns Observable
+     */
+    public delete<T>(url: string, headers?: HttpHeaders, options?: IApiOptions): Observable<T> {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        return this.myHttpClient.delete<T>(url, { ...options.httpOptions as {}, headers })
+            .pipe(
+                catchError((err: HttpErrorResponse): Observable<never> => this.handleError(err, options)),
+            );
+    }
+
+    /**
+     * Appends a script to the html body
+     * @param path
+     * @param attributes
+     * @param onLoad
+     */
+    public loadExternalScript(path: string, attributes?: { key: string, value: string }[],
+                              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                              onLoad?: ((this: GlobalEventHandlers, ev: Event) => any)): void {
+        const script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = path;
+        script.async = true;
+
+        if (onLoad) {
+            script.onload = onLoad;
+        }
+
+        if (attributes) {
+            for (const attribute of attributes) {
+                script.setAttribute(attribute.key, attribute.value);
+            }
+        }
+
+        document.body.append(script);
+    }
+
+    private handleError(err: HttpErrorResponse, options: IApiOptions): Observable<never> {
+        if (!options?.skipErrorHandling) {
+            this.myCoreLoggerService.logError({ msg: err });
+        }
+
+        return throwError(err);
+    }
+
+    private handleResponse<T>(response: HttpEvent<T>): T {
+        if (response instanceof HttpResponse) {
+            return response.body;
+        }
+        return response as T;
+    }
+
+    private getHeaders(headers: HttpHeaders, options: IApiOptions): HttpHeaders {
+        if (!headers) {
+            headers = new HttpHeaders();
+        }
+
+        if (!options.skipContentType) {
+            if (!headers.get('Content-Type')) {
+                headers = headers.set('Content-Type', 'application/json');
+            }
+        }
+
+        if (!options?.skipAuth) {
+            if (this.getToken()) {
+                const tokenSettings: ITokenSettings = this.getToken();
+                headers = headers.set('Authorization', `${ tokenSettings.tokenType } ${ tokenSettings.token }`);
+            } else {
+                // Deprecated. Use ITokenSettings
+                headers = headers.set('Authorization', `Bearer ${ this.getAccessToken() }`);
+            }
+        }
+        return headers;
+    }
+
+    private static serializeOptions(options: IApiOptions): IApiOptions {
+        if (!options) {
+            options = {};
+        }
+
+        if (!options.httpOptions) {
+            options.httpOptions = {};
+        }
+
+        return options;
+    }
+}