@simpleangularcontrols/sac-common 13.0.0-rc.5 → 16.0.0-rc.2

package/esm2022/controls/upload/dropzonesingle.mjs

@@ -0,0 +1,107 @@
+import { Directive, Input } from '@angular/core';
+import { SacUploadBase } from '../../common/baseuploadcontrol';
+import * as i0 from "@angular/core";
+/**
+ * Upload Komponente für ein einzelnes File
+ */
+class SacDropzoneSingleCommon extends SacUploadBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Höhe der Dropzone. Wert wird mit Einheit angegeben.
+         */
+        this.uploadheight = null;
+        /**
+         * Property wenn Drag Event aktiv ist (Maus über Zone)
+         */
+        this.active = false;
+    }
+    /**
+     * Ervent wenn das Control initialisert wird
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.autoupload = true;
+    }
+    /**
+     * Methode für Drag and Drop von Files
+     * @param event Drag Event
+     */
+    dropHandler(event) {
+        if (!this.HasQueueItem() &&
+            event.dataTransfer &&
+            event.dataTransfer.files &&
+            event.dataTransfer.files.item(0)) {
+            event.stopPropagation();
+            event.preventDefault();
+            this.active = false;
+            if (event.dataTransfer.files.length === 1) {
+                this.uploadService.handleFiles(event.dataTransfer.files);
+            }
+            else {
+                this.onfileerror.emit('INVALID_DRAGDROP_MAXFILES');
+            }
+        }
+    }
+    /**
+     * Methode wenn Drag in die Zone eintritt
+     * @param event DragEnter Event
+     */
+    onDragOver(event) {
+        if (!this.HasQueueItem() &&
+            event.dataTransfer &&
+            event.dataTransfer.files &&
+            event.dataTransfer.types.every((itm) => itm === 'Files') &&
+            event.dataTransfer.types.length > 0) {
+            event.dataTransfer.dropEffect = 'copy';
+            event.stopPropagation();
+            event.preventDefault();
+            this.active = true;
+        }
+    }
+    /**
+     * Methode wenn Drag die Zone verlässt
+     * @param event DragLeave Event
+     */
+    onDragLeave(event) {
+        this.active = false;
+    }
+    /**
+     * Macht keine Validierung in diesem Control
+     *
+     * @param file File das hinzugefügt wurde
+     */
+    CustomAddValidation(file) {
+        return true;
+    }
+    /**
+     * Setzt die File ID des hochgeladen Files in das Model
+     *
+     * @param file ID des Files
+     */
+    SetUploadValue(file) {
+        if (file === null) {
+            super.setValue(null);
+        }
+        else {
+            if (file.response !== undefined &&
+                file.response !== null &&
+                file.response.documentid !== null &&
+                file.response.documentid !== undefined) {
+                super.setValue(file.response.documentid);
+            }
+            else {
+                super.setValue(file.uploadId);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDropzoneSingleCommon, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacDropzoneSingleCommon, inputs: { uploadheight: "uploadheight" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { SacDropzoneSingleCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDropzoneSingleCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { uploadheight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcHpvbmVzaW5nbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb250cm9scy91cGxvYWQvZHJvcHpvbmVzaW5nbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFFekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGdDQUFnQyxDQUFDOztBQUUvRDs7R0FFRztBQUNILE1BQ2EsdUJBQ1gsU0FBUSxhQUFxQjtJQUYvQjs7UUFLRTs7V0FFRztRQUVJLGlCQUFZLEdBQVcsSUFBSSxDQUFDO1FBRW5DOztXQUVHO1FBQ0ksV0FBTSxHQUFHLEtBQUssQ0FBQztLQTJGdkI7SUF6RkM7O09BRUc7SUFDSCxRQUFRO1FBQ04sS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBRWpCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO0lBQ3pCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxXQUFXLENBQUMsS0FBZ0I7UUFDMUIsSUFDRSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUU7WUFDcEIsS0FBSyxDQUFDLFlBQVk7WUFDbEIsS0FBSyxDQUFDLFlBQVksQ0FBQyxLQUFLO1lBQ3hCLEtBQUssQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFDaEM7WUFDQSxLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDeEIsS0FBSyxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO1lBRXBCLElBQUksS0FBSyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtnQkFDekMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQzthQUMxRDtpQkFBTTtnQkFDTCxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO2FBQ3BEO1NBQ0Y7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsVUFBVSxDQUFDLEtBQWdCO1FBQ3pCLElBQ0UsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFO1lBQ3BCLEtBQUssQ0FBQyxZQUFZO1lBQ2xCLEtBQUssQ0FBQyxZQUFZLENBQUMsS0FBSztZQUN4QixLQUFLLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsS0FBSyxPQUFPLENBQUM7WUFDeEQsS0FBSyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsRUFDbkM7WUFDQSxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUM7WUFDdkMsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ3hCLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUN2QixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztTQUNwQjtJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSCxXQUFXLENBQUMsS0FBZ0I7UUFDMUIsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7SUFDdEIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxtQkFBbUIsQ0FBQyxJQUFpQjtRQUNuQyxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsY0FBYyxDQUFDLElBQWlCO1FBQzlCLElBQUksSUFBSSxLQUFLLElBQUksRUFBRTtZQUNqQixLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQ3RCO2FBQU07WUFDTCxJQUNFLElBQUksQ0FBQyxRQUFRLEtBQUssU0FBUztnQkFDM0IsSUFBSSxDQUFDLFFBQVEsS0FBSyxJQUFJO2dCQUN0QixJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsS0FBSyxJQUFJO2dCQUNqQyxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsS0FBSyxTQUFTLEVBQ3RDO2dCQUNBLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQzthQUMxQztpQkFBTTtnQkFDTCxLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQzthQUMvQjtTQUNGO0lBQ0gsQ0FBQzsrR0F2R1UsdUJBQXVCO21HQUF2Qix1QkFBdUI7O1NBQXZCLHVCQUF1Qjs0RkFBdkIsdUJBQXVCO2tCQURuQyxTQUFTOzhCQVNELFlBQVk7c0JBRGxCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgVXBsb2FkU3RhdGUgfSBmcm9tICduZ3gtdXBsb2FkeCc7XHJcbmltcG9ydCB7IFNhY1VwbG9hZEJhc2UgfSBmcm9tICcuLi8uLi9jb21tb24vYmFzZXVwbG9hZGNvbnRyb2wnO1xyXG5cclxuLyoqXHJcbiAqIFVwbG9hZCBLb21wb25lbnRlIGbDvHIgZWluIGVpbnplbG5lcyBGaWxlXHJcbiAqL1xyXG5ARGlyZWN0aXZlKClcclxuZXhwb3J0IGNsYXNzIFNhY0Ryb3B6b25lU2luZ2xlQ29tbW9uXHJcbiAgZXh0ZW5kcyBTYWNVcGxvYWRCYXNlPHN0cmluZz5cclxuICBpbXBsZW1lbnRzIE9uSW5pdFxyXG57XHJcbiAgLyoqXHJcbiAgICogSMO2aGUgZGVyIERyb3B6b25lLiBXZXJ0IHdpcmQgbWl0IEVpbmhlaXQgYW5nZWdlYmVuLlxyXG4gICAqL1xyXG4gIEBJbnB1dCgpXHJcbiAgcHVibGljIHVwbG9hZGhlaWdodDogc3RyaW5nID0gbnVsbDtcclxuXHJcbiAgLyoqXHJcbiAgICogUHJvcGVydHkgd2VubiBEcmFnIEV2ZW50IGFrdGl2IGlzdCAoTWF1cyDDvGJlciBab25lKVxyXG4gICAqL1xyXG4gIHB1YmxpYyBhY3RpdmUgPSBmYWxzZTtcclxuXHJcbiAgLyoqXHJcbiAgICogRXJ2ZW50IHdlbm4gZGFzIENvbnRyb2wgaW5pdGlhbGlzZXJ0IHdpcmRcclxuICAgKi9cclxuICBuZ09uSW5pdCgpIHtcclxuICAgIHN1cGVyLm5nT25Jbml0KCk7XHJcblxyXG4gICAgdGhpcy5hdXRvdXBsb2FkID0gdHJ1ZTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIE1ldGhvZGUgZsO8ciBEcmFnIGFuZCBEcm9wIHZvbiBGaWxlc1xyXG4gICAqIEBwYXJhbSBldmVudCBEcmFnIEV2ZW50XHJcbiAgICovXHJcbiAgZHJvcEhhbmRsZXIoZXZlbnQ6IERyYWdFdmVudCk6IHZvaWQge1xyXG4gICAgaWYgKFxyXG4gICAgICAhdGhpcy5IYXNRdWV1ZUl0ZW0oKSAmJlxyXG4gICAgICBldmVudC5kYXRhVHJhbnNmZXIgJiZcclxuICAgICAgZXZlbnQuZGF0YVRyYW5zZmVyLmZpbGVzICYmXHJcbiAgICAgIGV2ZW50LmRhdGFUcmFuc2Zlci5maWxlcy5pdGVtKDApXHJcbiAgICApIHtcclxuICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7XHJcbiAgICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7XHJcbiAgICAgIHRoaXMuYWN0aXZlID0gZmFsc2U7XHJcblxyXG4gICAgICBpZiAoZXZlbnQuZGF0YVRyYW5zZmVyLmZpbGVzLmxlbmd0aCA9PT0gMSkge1xyXG4gICAgICAgIHRoaXMudXBsb2FkU2VydmljZS5oYW5kbGVGaWxlcyhldmVudC5kYXRhVHJhbnNmZXIuZmlsZXMpO1xyXG4gICAgICB9IGVsc2Uge1xyXG4gICAgICAgIHRoaXMub25maWxlZXJyb3IuZW1pdCgnSU5WQUxJRF9EUkFHRFJPUF9NQVhGSUxFUycpO1xyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBNZXRob2RlIHdlbm4gRHJhZyBpbiBkaWUgWm9uZSBlaW50cml0dFxyXG4gICAqIEBwYXJhbSBldmVudCBEcmFnRW50ZXIgRXZlbnRcclxuICAgKi9cclxuICBvbkRyYWdPdmVyKGV2ZW50OiBEcmFnRXZlbnQpOiB2b2lkIHtcclxuICAgIGlmIChcclxuICAgICAgIXRoaXMuSGFzUXVldWVJdGVtKCkgJiZcclxuICAgICAgZXZlbnQuZGF0YVRyYW5zZmVyICYmXHJcbiAgICAgIGV2ZW50LmRhdGFUcmFuc2Zlci5maWxlcyAmJlxyXG4gICAgICBldmVudC5kYXRhVHJhbnNmZXIudHlwZXMuZXZlcnkoKGl0bSkgPT4gaXRtID09PSAnRmlsZXMnKSAmJlxyXG4gICAgICBldmVudC5kYXRhVHJhbnNmZXIudHlwZXMubGVuZ3RoID4gMFxyXG4gICAgKSB7XHJcbiAgICAgIGV2ZW50LmRhdGFUcmFuc2Zlci5kcm9wRWZmZWN0ID0gJ2NvcHknO1xyXG4gICAgICBldmVudC5zdG9wUHJvcGFnYXRpb24oKTtcclxuICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcclxuICAgICAgdGhpcy5hY3RpdmUgPSB0cnVlO1xyXG4gICAgfVxyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogTWV0aG9kZSB3ZW5uIERyYWcgZGllIFpvbmUgdmVybMOkc3N0XHJcbiAgICogQHBhcmFtIGV2ZW50IERyYWdMZWF2ZSBFdmVudFxyXG4gICAqL1xyXG4gIG9uRHJhZ0xlYXZlKGV2ZW50OiBEcmFnRXZlbnQpOiB2b2lkIHtcclxuICAgIHRoaXMuYWN0aXZlID0gZmFsc2U7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBNYWNodCBrZWluZSBWYWxpZGllcnVuZyBpbiBkaWVzZW0gQ29udHJvbFxyXG4gICAqXHJcbiAgICogQHBhcmFtIGZpbGUgRmlsZSBkYXMgaGluenVnZWbDvGd0IHd1cmRlXHJcbiAgICovXHJcbiAgQ3VzdG9tQWRkVmFsaWRhdGlvbihmaWxlOiBVcGxvYWRTdGF0ZSk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRydWU7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBTZXR6dCBkaWUgRmlsZSBJRCBkZXMgaG9jaGdlbGFkZW4gRmlsZXMgaW4gZGFzIE1vZGVsXHJcbiAgICpcclxuICAgKiBAcGFyYW0gZmlsZSBJRCBkZXMgRmlsZXNcclxuICAgKi9cclxuICBTZXRVcGxvYWRWYWx1ZShmaWxlOiBVcGxvYWRTdGF0ZSkge1xyXG4gICAgaWYgKGZpbGUgPT09IG51bGwpIHtcclxuICAgICAgc3VwZXIuc2V0VmFsdWUobnVsbCk7XHJcbiAgICB9IGVsc2Uge1xyXG4gICAgICBpZiAoXHJcbiAgICAgICAgZmlsZS5yZXNwb25zZSAhPT0gdW5kZWZpbmVkICYmXHJcbiAgICAgICAgZmlsZS5yZXNwb25zZSAhPT0gbnVsbCAmJlxyXG4gICAgICAgIGZpbGUucmVzcG9uc2UuZG9jdW1lbnRpZCAhPT0gbnVsbCAmJlxyXG4gICAgICAgIGZpbGUucmVzcG9uc2UuZG9jdW1lbnRpZCAhPT0gdW5kZWZpbmVkXHJcbiAgICAgICkge1xyXG4gICAgICAgIHN1cGVyLnNldFZhbHVlKGZpbGUucmVzcG9uc2UuZG9jdW1lbnRpZCk7XHJcbiAgICAgIH0gZWxzZSB7XHJcbiAgICAgICAgc3VwZXIuc2V0VmFsdWUoZmlsZS51cGxvYWRJZCk7XHJcbiAgICAgIH1cclxuICAgIH1cclxuICB9XHJcbn1cclxuIl19

package/esm2022/controls/upload/uploadmultiple.mjs

@@ -0,0 +1,125 @@
+import { Directive, Input } from '@angular/core';
+import { SacUploadBase } from '../../common/baseuploadcontrol';
+import { Validation } from '../../validation';
+import * as i0 from "@angular/core";
+/**
+ * Upload Componente für mehrere Files
+ */
+class SacUploadMultipleCommon extends SacUploadBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Max. Files die hochgeladen werden können. 0 deaktiviert das Limit
+         */
+        this.maxfiles = 0;
+        /**
+         * Min. Files die hochgeladen werden müssen. 0 deaktiviert das Limit
+         */
+        this.minfiles = 0;
+        /**
+         * Label für Browse Button
+         */
+        this.buttonbrowse = 'Browse';
+        /**
+         * Label für Upload Button
+         */
+        this.buttonupload = 'Upload';
+        /**
+         * Resource Key für Validation Message Required bei Control
+         */
+        this.validationmessageminfiles = 'VALIDATION_ERROR_FILESMIN';
+        /**
+         * Resource Key für Validation Message Required in Validation Summary
+         */
+        this.validationmessagesummaryminfiles = 'VALIDATION_ERROR_SUMMARY_FILESMIN';
+    }
+    /**
+     * Prüft ob die max. Files in der Queue nicht überschritten werden
+     *
+     * @param file File das hinzugefügt wurde
+     */
+    CustomAddValidation(file) {
+        if (this.maxfiles > 0 && this.uploads.length >= this.maxfiles) {
+            this.onfileerror.emit('INVALID_MAXFILES');
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Setzt die File ID's der hochgeladen Files in das Model
+     *
+     * @param file ID des Files welches hochgeladen wurde.
+     */
+    SetUploadValue(file) {
+        let documentid = null;
+        if (file === null) {
+            documentid = null;
+        }
+        else {
+            if (file.response !== undefined &&
+                file.response !== null &&
+                file.response.documentid !== null &&
+                file.response.documentid !== undefined) {
+                documentid = file.response.documentid;
+            }
+            else {
+                documentid = file.uploadId;
+            }
+            // Document ID aktualisieren, damit Wert von Server in Model gesetzt werden kann.
+            this.uploads
+                .filter((itm) => itm !== null && itm.uploadId === file.uploadId)
+                .forEach((itm) => {
+                itm.documentid = documentid;
+            });
+        }
+        // List of Files
+        const fileIds = [];
+        // Add all Items with Uploaded State to Model
+        this.uploads
+            .filter((itm) => itm.status === 'complete')
+            .forEach((itm) => {
+            if (itm.documentid !== null && itm.documentid !== undefined) {
+                fileIds.push(itm.documentid);
+            }
+        });
+        if (fileIds.length > 0) {
+            super.setValue(fileIds);
+        }
+        else {
+            super.setValue(null);
+        }
+    }
+    /**
+     * Validiert das Control
+     *
+     * @param c Control
+     */
+    validateData(c) {
+        let error = super.validateData(c);
+        if (error === null) {
+            error = Validation.minFiles(this.minfiles, this.validationmessageminfiles, this.validationmessagesummaryminfiles)(c);
+        }
+        return error;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacUploadMultipleCommon, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacUploadMultipleCommon, inputs: { maxfiles: "maxfiles", minfiles: "minfiles", buttonbrowse: "buttonbrowse", buttonupload: "buttonupload", validationmessageminfiles: "validationmessageminfiles", validationmessagesummaryminfiles: "validationmessagesummaryminfiles" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { SacUploadMultipleCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacUploadMultipleCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { maxfiles: [{
+                type: Input
+            }], minfiles: [{
+                type: Input
+            }], buttonbrowse: [{
+                type: Input
+            }], buttonupload: [{
+                type: Input
+            }], validationmessageminfiles: [{
+                type: Input
+            }], validationmessagesummaryminfiles: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploadmultiple.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/upload/uploadmultiple.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input } from '@angular/core';\r\nimport { AbstractControl, ValidationErrors } from '@angular/forms';\r\nimport { UploadState } from 'ngx-uploadx';\r\nimport { SacUploadBase } from '../../common/baseuploadcontrol';\r\nimport { IUploadControl } from '../../interfaces/iuploadcontrol';\r\nimport { Validation } from '../../validation';\r\n\r\n/**\r\n * Upload Componente für mehrere Files\r\n */\r\n@Directive()\r\nexport class SacUploadMultipleCommon extends SacUploadBase<string[]> {\r\n  /**\r\n   * Max. Files die hochgeladen werden können. 0 deaktiviert das Limit\r\n   */\r\n  @Input()\r\n  public maxfiles: number = 0;\r\n\r\n  /**\r\n   * Min. Files die hochgeladen werden müssen. 0 deaktiviert das Limit\r\n   */\r\n  @Input()\r\n  public minfiles: number = 0;\r\n\r\n  /**\r\n   * Label für Browse Button\r\n   */\r\n  @Input()\r\n  buttonbrowse: string = 'Browse';\r\n\r\n  /**\r\n   * Label für Upload Button\r\n   */\r\n  @Input()\r\n  buttonupload: string = 'Upload';\r\n\r\n  /**\r\n   * Resource Key für Validation Message Required bei Control\r\n   */\r\n  @Input() validationmessageminfiles: string = 'VALIDATION_ERROR_FILESMIN';\r\n  /**\r\n   * Resource Key für Validation Message Required in Validation Summary\r\n   */\r\n  @Input()\r\n  validationmessagesummaryminfiles: string =\r\n    'VALIDATION_ERROR_SUMMARY_FILESMIN';\r\n\r\n  /**\r\n   * Prüft ob die max. Files in der Queue nicht überschritten werden\r\n   *\r\n   * @param file File das hinzugefügt wurde\r\n   */\r\n  CustomAddValidation(file: UploadState): boolean {\r\n    if (this.maxfiles > 0 && this.uploads.length >= this.maxfiles) {\r\n      this.onfileerror.emit('INVALID_MAXFILES');\r\n      return false;\r\n    } else {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setzt die File ID's der hochgeladen Files in das Model\r\n   *\r\n   * @param file ID des Files welches hochgeladen wurde.\r\n   */\r\n  SetUploadValue(file: UploadState) {\r\n    let documentid: string = null;\r\n    if (file === null) {\r\n      documentid = null;\r\n    } else {\r\n      if (\r\n        file.response !== undefined &&\r\n        file.response !== null &&\r\n        file.response.documentid !== null &&\r\n        file.response.documentid !== undefined\r\n      ) {\r\n        documentid = file.response.documentid;\r\n      } else {\r\n        documentid = file.uploadId;\r\n      }\r\n\r\n      // Document ID aktualisieren, damit Wert von Server in Model gesetzt werden kann.\r\n      this.uploads\r\n        .filter((itm) => itm !== null && itm.uploadId === file.uploadId)\r\n        .forEach((itm) => {\r\n          itm.documentid = documentid;\r\n        });\r\n    }\r\n\r\n    // List of Files\r\n    const fileIds: string[] = [];\r\n\r\n    // Add all Items with Uploaded State to Model\r\n    this.uploads\r\n      .filter((itm) => itm.status === 'complete')\r\n      .forEach((itm) => {\r\n        if (itm.documentid !== null && itm.documentid !== undefined) {\r\n          fileIds.push(itm.documentid);\r\n        }\r\n      });\r\n\r\n    if (fileIds.length > 0) {\r\n      super.setValue(fileIds);\r\n    } else {\r\n      super.setValue(null);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validiert das Control\r\n   *\r\n   * @param c Control\r\n   */\r\n  validateData(c: AbstractControl): ValidationErrors | null {\r\n    let error: ValidationErrors | null = super.validateData(c);\r\n\r\n    if (error === null) {\r\n      error = Validation.minFiles(\r\n        this.minfiles,\r\n        this.validationmessageminfiles,\r\n        this.validationmessagesummaryminfiles\r\n      )(c);\r\n    }\r\n\r\n    return error;\r\n  }\r\n}\r\n"]}

package/esm2022/controls/upload/uploadsingle.mjs

@@ -0,0 +1,59 @@
+import { Directive, Input } from '@angular/core';
+import { SacUploadBase } from '../../common/baseuploadcontrol';
+import * as i0 from "@angular/core";
+/**
+ * Upload Komponente für ein einzelnes File
+ */
+class SacUploadSingleCommon extends SacUploadBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Label für Browse Button
+         */
+        this.buttonbrowse = 'Browse';
+        /**
+         * Label für Upload Button
+         */
+        this.buttonupload = 'Upload';
+    }
+    /**
+     * Macht keine Validierung in diesem Control
+     *
+     * @param file File das hinzugefügt wurde
+     */
+    CustomAddValidation(file) {
+        return true;
+    }
+    /**
+     * Setzt die File ID des hochgeladen Files in das Model
+     *
+     * @param file ID des Files
+     */
+    SetUploadValue(file) {
+        if (file === null) {
+            super.setValue(null);
+        }
+        else {
+            if (file.response !== undefined &&
+                file.response !== null &&
+                file.response.documentid !== null &&
+                file.response.documentid !== undefined) {
+                super.setValue(file.response.documentid);
+            }
+            else {
+                super.setValue(file.uploadId);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacUploadSingleCommon, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacUploadSingleCommon, inputs: { buttonbrowse: "buttonbrowse", buttonupload: "buttonupload" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { SacUploadSingleCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacUploadSingleCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { buttonbrowse: [{
+                type: Input
+            }], buttonupload: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/controls/validation/validationsummary.mjs

@@ -0,0 +1,128 @@
+import { Directive, Input } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { SacDefaultLocalisationService, SACLOCALISATION_SERVICE, } from '../../services/sac-localisation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../form/form";
+/**
+ * Basis Komponente für SacValidationSummary
+ */
+class SacValidationSummaryCommon {
+    // #endregion
+    // #region Constructor
+    /**
+     * Konstruktor
+     * Inject des Formulars
+     */
+    constructor(parent, injector) {
+        /**
+         * Name-Property
+         */
+        this.name = '';
+        this.parent = parent;
+        this.lngResourceService = injector.get(SACLOCALISATION_SERVICE, new SacDefaultLocalisationService());
+    }
+    // #endregion
+    /**
+     * Validation Methode
+     */
+    get formErrors() {
+        const collection = new Array();
+        let formBase;
+        if (this.parent) {
+            formBase = this.parent.getForm().form;
+        }
+        else if (this.form instanceof UntypedFormGroup) {
+            formBase = this.form;
+            // formgroup can only be get in reactive forms mode
+            if (this.formGroupName) {
+                formBase = formBase.get(this.formGroupName);
+            }
+        }
+        else {
+            throw new Error('missing form');
+        }
+        const items = Object.keys(formBase.controls).map((key) => {
+            return formBase.controls[key];
+        });
+        this.getErrorCollection(items, collection);
+        return collection.filter((item) => item !== null);
+    }
+    /**
+     * Die Methode gibt Collection von Errors. Verlangt controls: Array<NgForm | FormArray> und  collection: Array<Observable<string>>
+     */
+    getErrorCollection(controls, collection) {
+        controls.forEach((ctl) => {
+            if (ctl.controls === undefined || ctl.controls === null) {
+                this.addErrorToCollection(ctl, collection);
+            }
+            else {
+                Object.keys(ctl.controls).map((controlKey) => {
+                    const control = ctl.controls[controlKey];
+                    // Cancel Analyse wenn Item not Touched oder Valid
+                    if (control.touched === false || control.valid === true) {
+                        return;
+                    }
+                    // Handle wenn Control kein Container ist
+                    if (control.controls === undefined || control.controls === null) {
+                        this.addErrorToCollection(control, collection);
+                    }
+                    else {
+                        // Handling eines Control Containers
+                        const items = Object.keys(control.controls).map((formKey) => {
+                            return control.controls[formKey];
+                        });
+                        this.getErrorCollection(items, collection);
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Fügt einen Validation Error in die Error Collection hinzu
+     * @param ctl Fehlerhaftes Control
+     * @param collection Collection aller Fehlermeldungen
+     */
+    addErrorToCollection(ctl, collection) {
+        if (ctl.errors === null || ctl.touched === false || ctl.valid === true) {
+            return;
+        }
+        const keys = Object.keys(ctl.errors);
+        if (keys.length <= 0) {
+            return;
+        }
+        const errorItem = ctl.errors[keys[0]];
+        // Validation Parameters
+        const parameters = {};
+        if (errorItem.parameters !== null && errorItem.parameters !== undefined) {
+            errorItem.parameters.forEach((v, k) => {
+                parameters[k] = v;
+            });
+        }
+        if (ctl?.controllabel) {
+            parameters['FIELD'] = ctl.controllabel;
+        }
+        else {
+            parameters['FIELD'] = errorItem.fieldName;
+        }
+        collection.push(this.lngResourceService.GetString(errorItem.errorMessageValidationSummaryKey, parameters));
+    }
+    /**
+     * Getter wenn Errors entstehen
+     */
+    get hasErrors() {
+        return this.formErrors.length > 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacValidationSummaryCommon, deps: [{ token: i1.SacFormCommon }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacValidationSummaryCommon, inputs: { name: "name", form: "form", formGroupName: "formGroupName" }, ngImport: i0 }); }
+}
+export { SacValidationSummaryCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacValidationSummaryCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.SacFormCommon }, { type: i0.Injector }]; }, propDecorators: { name: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], formGroupName: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validationsummary.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/validation/validationsummary.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Injector, Input } from '@angular/core';\r\nimport { AbstractControl, UntypedFormArray, UntypedFormGroup, NgForm } from '@angular/forms';\r\nimport { Observable } from 'rxjs';\r\nimport { IAbstractControlLabelExtension } from '../../interfaces/iabstractcontrollabel';\r\nimport { ISacLocalisationService } from '../../interfaces/ISacLocalisationService';\r\nimport {\r\n  SacDefaultLocalisationService,\r\n  SACLOCALISATION_SERVICE,\r\n} from '../../services/sac-localisation.service';\r\nimport { ValidationErrorItem } from '../../validation';\r\nimport { SacFormCommon } from '../form/form';\r\n\r\n/**\r\n * Basis Komponente für SacValidationSummary\r\n */\r\n@Directive()\r\nexport class SacValidationSummaryCommon {\r\n  /**\r\n   * Name-Property\r\n   */\r\n  @Input()\r\n  name: string = '';\r\n\r\n  /**\r\n   * reactive form instance\r\n   */\r\n  @Input()\r\n  form: UntypedFormGroup;\r\n\r\n  /**\r\n   * Form groupname to filter summary to formgroup\r\n   *\r\n   * Important: it works only in reactive forms mode.\r\n   */\r\n  @Input()\r\n  formGroupName: string;\r\n\r\n  // #region Private Variables\r\n\r\n  /**\r\n   * Parent Formular\r\n   */\r\n  protected parent: SacFormCommon;\r\n  /**\r\n   * Service für Error Localisation\r\n   */\r\n  protected lngResourceService: ISacLocalisationService;\r\n\r\n  // #endregion\r\n\r\n  // #region Constructor\r\n\r\n  /**\r\n   * Konstruktor\r\n   * Inject des Formulars\r\n   */\r\n  constructor(parent: SacFormCommon, injector: Injector) {\r\n    this.parent = parent;\r\n    this.lngResourceService = injector.get(\r\n      SACLOCALISATION_SERVICE,\r\n      new SacDefaultLocalisationService()\r\n    );\r\n  }\r\n\r\n  // #endregion\r\n\r\n  /**\r\n   * Validation Methode\r\n   */\r\n  get formErrors(): Observable<string>[] {\r\n    const collection: Array<Observable<string>> = new Array<\r\n      Observable<string>\r\n    >();\r\n\r\n    let formBase: UntypedFormGroup;\r\n    if (this.parent) {\r\n      formBase = this.parent.getForm().form;\r\n    } else if (this.form instanceof UntypedFormGroup) {\r\n      formBase = this.form;\r\n\r\n      // formgroup can only be get in reactive forms mode\r\n      if (this.formGroupName) {\r\n        formBase = formBase.get(this.formGroupName) as UntypedFormGroup;\r\n      }\r\n    } else {\r\n      throw new Error('missing form');\r\n    }\r\n\r\n    const items: Array<NgForm | UntypedFormArray> = Object.keys(formBase.controls).map(\r\n      (key) => {\r\n        return <NgForm | UntypedFormArray>formBase.controls[key];\r\n      }\r\n    );\r\n\r\n    this.getErrorCollection(items, collection);\r\n\r\n    return collection.filter((item) => item !== null);\r\n  }\r\n\r\n  /**\r\n   * Die Methode gibt Collection von Errors. Verlangt controls: Array<NgForm | FormArray> und  collection: Array<Observable<string>>\r\n   */\r\n  private getErrorCollection(\r\n    controls: Array<NgForm | UntypedFormArray>,\r\n    collection: Array<Observable<string>>\r\n  ): void {\r\n    controls.forEach((ctl) => {\r\n      if (ctl.controls === undefined || ctl.controls === null) {\r\n        this.addErrorToCollection(<AbstractControl>ctl, collection);\r\n      } else {\r\n        Object.keys(ctl.controls).map((controlKey) => {\r\n          const control = ctl.controls[controlKey];\r\n\r\n          // Cancel Analyse wenn Item not Touched oder Valid\r\n          if (control.touched === false || control.valid === true) {\r\n            return;\r\n          }\r\n\r\n          // Handle wenn Control kein Container ist\r\n          if (control.controls === undefined || control.controls === null) {\r\n            this.addErrorToCollection(control, collection);\r\n          } else {\r\n            // Handling eines Control Containers\r\n            const items: Array<NgForm | UntypedFormArray> = Object.keys(\r\n              control.controls\r\n            ).map((formKey) => {\r\n              return <NgForm | UntypedFormArray>control.controls[formKey];\r\n            });\r\n\r\n            this.getErrorCollection(items, collection);\r\n          }\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Fügt einen Validation Error in die Error Collection hinzu\r\n   * @param ctl Fehlerhaftes Control\r\n   * @param collection Collection aller Fehlermeldungen\r\n   */\r\n  private addErrorToCollection(\r\n    ctl: AbstractControl,\r\n    collection: Array<Observable<string>>\r\n  ): void {\r\n    if (ctl.errors === null || ctl.touched === false || ctl.valid === true) {\r\n      return;\r\n    }\r\n\r\n    const keys: string[] = Object.keys(ctl.errors);\r\n\r\n    if (keys.length <= 0) {\r\n      return;\r\n    }\r\n\r\n    const errorItem: ValidationErrorItem = ctl.errors[keys[0]];\r\n\r\n    // Validation Parameters\r\n    const parameters = {};\r\n    if (errorItem.parameters !== null && errorItem.parameters !== undefined) {\r\n      errorItem.parameters.forEach((v, k) => {\r\n        parameters[k] = v;\r\n      });\r\n    }\r\n\r\n    if ((ctl as unknown as IAbstractControlLabelExtension)?.controllabel) {\r\n      parameters['FIELD'] = (\r\n        ctl as unknown as IAbstractControlLabelExtension\r\n      ).controllabel;\r\n    } else {\r\n      parameters['FIELD'] = errorItem.fieldName;\r\n    }\r\n\r\n    collection.push(\r\n      this.lngResourceService.GetString(\r\n        errorItem.errorMessageValidationSummaryKey,\r\n        parameters\r\n      )\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Getter wenn Errors entstehen\r\n   */\r\n  get hasErrors() {\r\n    return this.formErrors.length > 0;\r\n  }\r\n}\r\n"]}

package/esm2022/controls/wizard/wizard.mjs

@@ -0,0 +1,145 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Base Komponente für SacWizardCommon
+ */
+class SacWizardCommon {
+    constructor() {
+        /**
+         * Name des Controls
+         */
+        this.name = '';
+        /**
+         * Boolean Property prüft ob Navigation im Wizard disabled ist; default Wert - false
+         */
+        this.disablenavigation = false;
+        /**
+         * EventEmitter wenn der Schritt geändert wird
+         */
+        this.stepchanged = new EventEmitter();
+        /**
+         * Leere Implementation von 'propagateChange'. Muss gemacht werden, damit kein Fehler entsteht
+         */
+        this.propagateChange = () => { };
+        /**
+         * Leere Implementation von 'propagateTouch'. Muss gemacht werden, damit kein Fehler entsteht
+         */
+        this.propagateTouch = () => { };
+    }
+    /**
+     * Setter und Getter für aktueller Schritt
+     */
+    set currentstep(v) {
+        this.changeStep(v);
+        this.propagateChange(this._currentstep);
+    }
+    get currentstep() {
+        return this._currentstep;
+    }
+    setStepInternal(step) {
+        this._currentstep = step;
+        this.propagateChange(this._currentstep);
+    }
+    // #region Control initialisieren
+    /**
+     * AfterContentInit Event
+     */
+    ngAfterContentInit() {
+        this.initSteps();
+    }
+    /**
+     * Ursprünglicher Schritt wird selektiert
+     */
+    initSteps() {
+        const activeStep = this.wizardItems().filter((step) => step.active);
+        if (activeStep.length === 0) {
+            const initStep = this.wizardItems().toArray()[0];
+            this.selectStep(initStep);
+            initStep.disabled = false;
+            this.setStepInternal(initStep.id);
+        }
+    }
+    // #endregion
+    /**
+     * Schritt selektieren
+     * @param step Step welcher selektiert werden soll
+     */
+    selectStep(step) {
+        // Cancel if Navigation disabled
+        if (this.disablenavigation) {
+            return;
+        }
+        this.changeStep(step.id);
+    }
+    /**
+     * Auf nächsten/vorherigen Schritt gehen
+     * @param step Step auf welchen gewechselt werden soll
+     */
+    changeStep(step) {
+        if (this.wizardItems() === undefined || this.wizardItems() === null) {
+            return;
+        }
+        const wizardItemsArray = this.wizardItems().toArray();
+        const itemsCount = wizardItemsArray.length;
+        const currentItemIndex = wizardItemsArray.findIndex(itm => itm.id === step);
+        for (let i = 0; i < itemsCount; i++) {
+            const item = wizardItemsArray[i];
+            if (i < currentItemIndex) {
+                item.iscomplete = true;
+            }
+            else {
+                item.iscomplete = false;
+            }
+            if (i > currentItemIndex + 1) {
+                item.disabled = true;
+            }
+            else {
+                item.disabled = false;
+            }
+            if (i === currentItemIndex) {
+                item.active = true;
+            }
+            else {
+                item.active = false;
+            }
+        }
+        this.setStepInternal(step);
+        this.stepchanged.emit(step);
+    }
+    /**
+     * Methode, damit andere Controls änderungen im Control mitbekommen können
+     * Zur Änderungsinfo die Methode propagateChange aufrufen.
+     */
+    registerOnChange(fn) {
+        this.propagateChange = (obj) => fn(obj);
+    }
+    /**
+     * Methode, damit andere Controls änderungen mitbekommen, wenn das Control aktiviert (Focus) wird.
+     */
+    registerOnTouched(fn) {
+        this.propagateTouch = (obj) => fn(obj);
+    }
+    /**
+     * Methode zum schreiben von Werten aus dem Model in das Control
+     */
+    writeValue(value) {
+        if (value) {
+            this.changeStep(value);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacWizardCommon, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacWizardCommon, inputs: { name: "name", disablenavigation: "disablenavigation", currentstep: "currentstep" }, outputs: { stepchanged: "stepchanged" }, ngImport: i0 }); }
+}
+export { SacWizardCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacWizardCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { name: [{
+                type: Input
+            }], disablenavigation: [{
+                type: Input
+            }], currentstep: [{
+                type: Input
+            }], stepchanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/wizard/wizard.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, Directive, EventEmitter, Input, Output, QueryList } from '@angular/core';\r\nimport { ControlValueAccessor } from '@angular/forms';\r\nimport { SacWizardItemCommon } from './wizarditem';\r\n\r\n/**\r\n * Base Komponente für SacWizardCommon\r\n */\r\n@Directive()\r\nexport abstract class SacWizardCommon implements AfterContentInit, ControlValueAccessor {\r\n\r\n  /**\r\n  * Aktueller Schritt im Wizard\r\n  */\r\n  private _currentstep: string;\r\n\r\n  /**\r\n   * Name des Controls\r\n   */\r\n  @Input()\r\n  name: string = '';\r\n\r\n  /**\r\n   * Boolean Property prüft ob Navigation im Wizard disabled ist; default Wert - false\r\n   */\r\n  @Input()\r\n  disablenavigation: boolean = false;\r\n\r\n  /**\r\n   * Setter und Getter für aktueller Schritt\r\n   */\r\n  @Input()\r\n  set currentstep(v: string | null) {\r\n    this.changeStep(v);\r\n    this.propagateChange(this._currentstep);\r\n  }\r\n  get currentstep(): string | null {\r\n    return this._currentstep;\r\n  }\r\n  /**\r\n   * EventEmitter wenn der Schritt geändert wird\r\n   */\r\n  @Output()\r\n  stepchanged: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n\r\n  /**\r\n   * Abstrakte QueryList von SacWizardItemCommon\r\n   */\r\n  abstract wizardItems(): QueryList<SacWizardItemCommon>;\r\n\r\n  private setStepInternal(step: string): void {\r\n    this._currentstep = step;\r\n    this.propagateChange(this._currentstep);\r\n  }\r\n\r\n  // #region Control initialisieren\r\n\r\n  /**\r\n   * AfterContentInit Event\r\n   */\r\n  ngAfterContentInit() {\r\n    this.initSteps();\r\n  }\r\n  /**\r\n   * Ursprünglicher Schritt wird selektiert\r\n   */\r\n  private initSteps(): void {\r\n    const activeStep = this.wizardItems().filter((step) => step.active);\r\n\r\n    if (activeStep.length === 0) {\r\n      const initStep: SacWizardItemCommon = this.wizardItems().toArray()[0];\r\n      this.selectStep(initStep);\r\n      initStep.disabled = false;\r\n      this.setStepInternal(initStep.id);\r\n    }\r\n  }\r\n\r\n  // #endregion\r\n\r\n  /**\r\n   * Schritt selektieren\r\n   * @param step Step welcher selektiert werden soll\r\n   */\r\n  selectStep(step: SacWizardItemCommon): void {\r\n\r\n    // Cancel if Navigation disabled\r\n    if (this.disablenavigation) {\r\n      return;\r\n    }\r\n\r\n    this.changeStep(step.id);\r\n  }\r\n\r\n  /**\r\n   * Auf nächsten/vorherigen Schritt gehen\r\n   * @param step Step auf welchen gewechselt werden soll\r\n   */\r\n  changeStep(step: string | null) {\r\n    if (this.wizardItems() === undefined || this.wizardItems() === null) {\r\n      return;\r\n    }\r\n\r\n    const wizardItemsArray: SacWizardItemCommon[] = this.wizardItems().toArray();\r\n    const itemsCount: number = wizardItemsArray.length;\r\n    const currentItemIndex = wizardItemsArray.findIndex(itm => itm.id === step);\r\n\r\n    for (let i: number = 0; i < itemsCount; i++) {\r\n      const item: SacWizardItemCommon = wizardItemsArray[i];\r\n\r\n      if (i < currentItemIndex) {\r\n        item.iscomplete = true;\r\n      } else {\r\n        item.iscomplete = false;\r\n      }\r\n\r\n      if (i > currentItemIndex + 1) {\r\n        item.disabled = true;\r\n      } else {\r\n        item.disabled = false;\r\n      }\r\n\r\n      if (i === currentItemIndex) {\r\n        item.active = true;\r\n      } else {\r\n        item.active = false;\r\n      }\r\n    }\r\n\r\n    this.setStepInternal(step);\r\n    this.stepchanged.emit(step);\r\n  }\r\n\r\n  /**\r\n   * Leere Implementation von 'propagateChange'. Muss gemacht werden, damit kein Fehler entsteht\r\n   */\r\n  propagateChange: any = () => { };\r\n  /**\r\n   * Leere Implementation von 'propagateTouch'. Muss gemacht werden, damit kein Fehler entsteht\r\n   */\r\n  propagateTouch: any = () => { };\r\n\r\n\r\n  /**\r\n   * Methode, damit andere Controls änderungen im Control mitbekommen können\r\n   * Zur Änderungsinfo die Methode propagateChange aufrufen.\r\n   */\r\n  registerOnChange(fn: any): void {\r\n    this.propagateChange = (obj) => fn(obj);\r\n  }\r\n\r\n  /**\r\n   * Methode, damit andere Controls änderungen mitbekommen, wenn das Control aktiviert (Focus) wird.\r\n   */\r\n  registerOnTouched(fn: any): void {\r\n    this.propagateTouch = (obj) => fn(obj);\r\n  }\r\n\r\n  /**\r\n   * Methode zum schreiben von Werten aus dem Model in das Control\r\n   */\r\n  writeValue(value: string | null) {\r\n    if (value) {\r\n      this.changeStep(value);\r\n    }\r\n  }\r\n\r\n}\r\n"]}