gehgassi_backend/gehGassi.Web/TS/Core/Utility.ts

import { Tab } from "@syncfusion/ej2-navigations";
import { getInstance } from "@syncfusion/ej2-base";

export const millisecondsPerDay = 1000 * 60 * 60 * 24;

/**
 * Errechnet die Zeitspanne in Tagen zwischen 2 Datumswerten
 * @param {type} a: Datum 1
 * @param {type} b: Datum 2
 * @returns Zeitspanne in Tagen
 */
export function dateDiffInDays(a: Date, b: Date): number {

    var utc1 = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
    var utc2 = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());

    return Math.floor((utc2 - utc1) / millisecondsPerDay);
}

/**
 * Errechnet die Zeitspanne zwischen 2 Datumswerten in Jahren
 * @param a: Datum 1
 * @param b: Datum 2
 * @returns Zeitspanne in Jahren
 */
export function dateDiffInYears(a: Date, b: Date): number {
    return Math.floor((b.getFullYear() - a.getFullYear()));
}

/**
 * Entlädt ein Modul
 * @param {type} moduleName: Name des Moduls
 */
export function destroyModule(moduleName: string): void {
    try {
        var result = delete window[moduleName];
        window[moduleName] = null;
    } catch (e) {
        window[moduleName] = null;
    }
}

/**
 * Ist Sommerzeit aktiv?
 * @param {type} t Datum
 * @returns true wenn Sommerzeit, false sonst
 */
export function isDst(t: Date): boolean {
    var jan = new Date(t.getFullYear(), 0, 1);
    var jul = new Date(t.getFullYear(), 6, 1);
    return Math.min(jan.getTimezoneOffset(), jul.getTimezoneOffset()) === t.getTimezoneOffset();
}

/**
 * Voranstellen von 0 wenn nötig
 * @param {type} num Nummer
 * @param {type} size Anzahl Stellen
 * @returns
 */
function pad(num: number, size: number): string {
    var s = "000000000" + num;
    return s.substr(s.length - size);
}

/**
 * Gibt die Timezone als Offset in Stunden zurück
 * @returns Timezone als Offset in Stunden
 */
export function getTimezoneOffsetInHours(): string {
    var offset = new Date().getTimezoneOffset();
    if (isDst(new Date())) {
        offset -= (offset < 0 ? -60 : 60);
    }
    var minutes = Math.abs(offset);
    var hours = Math.floor(minutes / 60);
    minutes = minutes % 60;
    var prefix = offset < 0 ? "+" : "-";
    return prefix + pad(hours, 2) + ":" + pad(minutes, 2);
}

export function toUtcDate(dateToConvert: Date): Date {
    var offset = new Date().getTimezoneOffset();
    if (isDst(new Date())) {
        offset -= (offset < 0 ? -60 : 60);
    }
    var minutes = offset;
    if(minutes < 0)
        return new Date(dateToConvert.getTime() + (minutes * 60000));
    else if (minutes > 0)
        return new Date(dateToConvert.getTime() - (minutes * 60000));
    else
        return dateToConvert;
}

/**
 * Fügt an der Stelle des Cursors eines Feldes den angegebenen Text ein
 * @param id: ID des Feldes in welches der Text eingefügt werden soll
 * @param value: Text der eingefügt werden soll.
 */
export function insertAtCaret(id: string, value: string) {
    var field = $("#" + id);

    if (field === null || field === undefined) { return null; }

    return field.each(function (i) {
        var self = this as HTMLTextAreaElement;
        if (self.selectionStart || self.selectionStart === 0) {
            //For browsers like Firefox and Webkit based
            var startPos = self.selectionStart;
            var endPos = self.selectionEnd;
            var scrollTop = self.scrollTop;
            self.value = self.value.substring(0, startPos) + value + self.value.substring(endPos, self.value.length);
            self.focus();
            self.selectionStart = startPos + value.length;
            self.selectionEnd = startPos + value.length;
            self.scrollTop = scrollTop;
        } else {
            self.value += value;
            self.focus();
        }
    });

}

/**
 * Verzügert die Ausführung einer Funktion um X Millisekunden bis keine Interaktion mehr stattfindet
 * Beispiel: Suchbox die erst sucht wenn kein Input mehr stattfindet
 * @param fn: Funktion bzw. Callback
 * @param delay: Anzahl Millisekunden
 * @param immediate: wenn true, Funktion gleich ausführen und dann warten, ansonsten warten und dann ausführen
 */
export function debounce(fn: any, delay: number, immediate:boolean = false): any {
    var timer: any;
    return function () {
        var context = this, args = arguments;
        var later = function () {
            timer = null;
            if (!immediate) fn.apply(context, args);
        };
        var callNow = immediate && !timer;

        clearTimeout(timer);
        timer = setTimeout(later, delay);
        if (callNow) fn.apply(context, args);
    };
}

/**
 * Async Sleep Funktion
 * @param msec Zeit in Millisekunden
 */
export async function sleep(msec) {
    return new Promise(resolve => setTimeout(resolve, msec));
}

/**
 * Zeigt den ersten Tab syncfusion mit einem Fehler an
 */
export function showErrorTab(): void {
    const errorFound = $(".field-validation-error").first();
    if (errorFound !== undefined && errorFound !== null &&  errorFound.length > 0) {
        var parent = errorFound.closest(".e-item[role='tabpanel']");
        while (parent !== undefined && parent !== null && parent.length > 0) {
            var id = parent.attr("aria-labelledby");
            var tab = $(`#${id}`);
            var tabContainerElement = tab.closest(".e-control.e-tab");
            var tabContainer = <Tab>getInstance(tabContainerElement[0], Tab);
            tabContainer.select(tab[0]);
            parent = tab.closest(".e-item[role='tabpanel']");
        }
    }
}

/**
 * Hilfsfunktion für FIDO
 * @param thing
 * @param name
 */
export function coerceToArrayBuffer (thing:any, name?:any):any {
    if (typeof thing === "string") {
        // base64url to base64
        thing = thing.replace(/-/g, "+").replace(/_/g, "/");

        // base64 to Uint8Array
        var str = window.atob(thing);
        var bytes = new Uint8Array(str.length);
        for (var i = 0; i < str.length; i++) {
            bytes[i] = str.charCodeAt(i);
        }
        thing = bytes;
    }

    // Array to Uint8Array
    if (Array.isArray(thing)) {
        thing = new Uint8Array(thing);
    }

    // Uint8Array to ArrayBuffer
    if (thing instanceof Uint8Array) {
        thing = thing.buffer;
    }

    // error if none of the above worked
    if (!(thing instanceof ArrayBuffer)) {
        throw new TypeError(`could not coerce '${name}' to ArrayBuffer`);
    }

    return thing;
};

/**
 * Hilfsfunktion für FIDO
 * @param thing
 */
export function coerceToBase64Url(thing:any):any {
    // Array or ArrayBuffer to Uint8Array
    if (Array.isArray(thing)) {
        thing = Uint8Array.from(thing);
    }

    if (thing instanceof ArrayBuffer) {
        thing = new Uint8Array(thing);
    }

    // Uint8Array to base64
    if (thing instanceof Uint8Array) {
        var str = "";
        var len = thing.byteLength;

        for (var i = 0; i < len; i++) {
            str += String.fromCharCode(thing[i]);
        }
        thing = window.btoa(str);
    }

    if (typeof thing !== "string") {
        throw new Error("could not coerce to string");
    }

    // base64 to base64url
    // NOTE: "=" at the end of challenge is optional, strip it off here
    thing = thing.replace(/\+/g, "-").replace(/\//g, "_").replace(/=*$/g, "");

    return thing;
};