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

/**
 * Hilfsklasse für den Umgang mit Formularen
 */
export class Forms {

    private static _instance: Forms;
    private _errorClass: string = "has-error";
    private _validClass: string = "has-success";

    /**
     * Erstellt eine Instanz
     * @param name Eindeutiger Event-Name
     */
    constructor(errorClass: string, validClass: string) {
        this._errorClass = errorClass;
        this._validClass = validClass;
        this.init();
    }

    static getInstance(errorClass: string, validClass: string): Forms {
        if (!Forms._instance) {
            Forms._instance = new Forms(errorClass, validClass);
        }
        return Forms._instance;
    }

    /**
     * Initialisierung
     */
    private init(): void {
        this.setupBootstrap4ErrorHandling();
    }

    /**
    * Fehleranzeige mittels Bootstrap3 initialisieren
    */
    private setupBootstrap4ErrorHandling(): void {
        var self = this;
        const defaultOptions: JQueryValidation.ValidationOptions = {
            highlight(element) {
                $(element).removeClass(self._validClass);
                $(element).addClass(self._errorClass);
            },
            unhighlight(element) {
                $(element).removeClass(self._errorClass);
                $(element).addClass(self._validClass);
            },
            errorClass: self._errorClass,
            validClass: self._validClass
        };
        $.validator.setDefaults(defaultOptions);

        $.validator.unobtrusive.options = {
            errorClass: self._errorClass,
            validClass: self._validClass
        };
    }

    /**
    * Zurücksetzen der unobtrusive Validierung eines Forms
    * @param {string} formName: Name des Forms (optional). Wenn nicht angegeben, dann alle forms
    */
    public resetValidation(formName: string = ""): void {
        //Reset validation message
        $(".field-validation-error")
            .removeClass("field-validation-error")
            .addClass("field-validation-valid");

        //Reset input, select and textarea style
        $(".input-validation-error")
            .removeClass("input-validation-error")
            .addClass("valid");

        //Reset validation summary
        $(".validation-summary-errors")
            .removeClass("validation-summary-errors")
            .addClass("validation-summary-valid")
            .find("ul").empty();

        //To reenable lazy validation (no validation until you submit the form)
        if (formName.length === 0)
            formName = "form";
        $(formName).removeData("validator");
        $.validator.unobtrusive.parse($(formName));
    }
}

/**
 * Hilfsklasse für das Validieren von formularen
 */
export class FormValidation {

    private static _instance: FormValidation;
    private _formInterval: any;
    private _formValidCallback: any;
    private _formInvalidCallback: any;
    private _formName: string;

    /**
     * Erstellt eine Instanz
     * @param name Eindeutiger Event-Name
     */
    constructor() {
        this.init();
    }

    static getInstance(): FormValidation {
        if (!FormValidation._instance) {
            FormValidation._instance = new FormValidation();
        }
        return FormValidation._instance;
    }

    /**
     * Initialisierung
     */
    private init(): void {
        
    }

    /**
     * Warten auf Pending-Request
     */
    private waitForFormValidation(): void {
        var self = FormValidation._instance;
        let validator = <any>$(self._formName).validate();
        if (validator.pendingRequest === 0) {
            clearInterval(self._formInterval);
            if ($(self._formName).valid()) {
                // push your data or form submit
                self._formValidCallback();
            } else {
                self._formInvalidCallback();
            }
        }
    }

    /**
     * Validiert ein Form unter Berücksichtigung von Remote-Validation
     * @param formName
     * @param validCallback
     * @param invalidCallback
     */
    public validateForm(formName: string, validCallback: any, invalidCallback: any): void {
        var self = this;
        self._formName = formName;
        self._formValidCallback = validCallback;
        self._formInvalidCallback = invalidCallback;

        $(formName).valid();
        self._formInterval = setInterval(self.waitForFormValidation, 30);
    }
}