spiderly 0.0.2

package/esm2022/lib/components/base-details/role-base-details.component.mjs

@@ -0,0 +1,171 @@
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { TranslocoDirective } from '@jsverse/transloco';
+import { combineLatest, forkJoin, map, of } from 'rxjs';
+import { PrimengModule } from '../../modules/primeng.module';
+import { CardSkeletonComponent } from '../card-skeleton/card-skeleton.component';
+import { SpiderlyFormControl } from '../spiderly-form-control/spiderly-form-control';
+import { Role, RoleSaveBody } from '../../entities/security-entities';
+import { getControl, getPrimengAutocompleteNamebookOptions, getPrimengDropdownNamebookOptions, nameof } from '../../services/helper-functions';
+import { IsAuthorizedForSaveEvent } from '../../entities/is-authorized-for-save-event';
+import { SpiderlyTextboxComponent } from '../../controls/spiderly-textbox/spiderly-textbox.component';
+import { SpiderlyTextareaComponent } from '../../controls/spiderly-textarea/spiderly-textarea.component';
+import { SpiderlyMultiAutocompleteComponent } from '../../controls/spiderly-multiautocomplete/spiderly-multiautocomplete.component';
+import { SpiderlyMultiSelectComponent } from '../../controls/spiderly-multiselect/spiderly-multiselect.component';
+import { SpiderlyPanelsModule } from '../spiderly-panels/spiderly-panels.module';
+import { SpiderlyButtonComponent } from '../spiderly-buttons/spiderly-button/spiderly-button.component';
+import { SpiderlyReturnButtonComponent } from '../spiderly-buttons/return-button/return-button.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/api.service.security";
+import * as i2 from "@angular/router";
+import * as i3 from "../../services/base-form.service";
+import * as i4 from "../../services/auth-base.service";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "../spiderly-panels/panel-header/panel-header.component";
+import * as i8 from "../spiderly-panels/panel-body/panel-body.component";
+import * as i9 from "../spiderly-panels/panel-footer/panel-footer.component";
+import * as i10 from "../spiderly-panels/spiderly-panel/spiderly-panel.component";
+export class RoleBaseDetailsComponent {
+    constructor(apiService, route, baseFormService, authService) {
+        this.apiService = apiService;
+        this.route = route;
+        this.baseFormService = baseFormService;
+        this.authService = authService;
+        this.onSave = new EventEmitter();
+        this.onRoleFormGroupInitFinish = new EventEmitter();
+        this.additionalButtons = [];
+        this.authorizedForSaveObservable = () => of(false);
+        this.isAuthorizedForSave = false;
+        this.onIsAuthorizedForSaveChange = new EventEmitter();
+        this.loading = true;
+        this.roleSaveBodyName = nameof('roleDTO');
+        this.selectedUsersForRole = new SpiderlyFormControl(null, { updateOn: 'change' });
+        this.selectedPermissionsForRole = new SpiderlyFormControl(null, { updateOn: 'change' });
+        this.handleAuthorizationForSave = () => {
+            return combineLatest([this.authService.currentUserPermissionCodes$, this.authorizedForSaveObservable()]).pipe(map(([currentUserPermissionCodes, isAuthorizedForSave]) => {
+                if (currentUserPermissionCodes != null && isAuthorizedForSave != null) {
+                    this.isAuthorizedForSave =
+                        (currentUserPermissionCodes.includes('InsertRole') && this.modelId <= 0) ||
+                            (currentUserPermissionCodes.includes('UpdateRole') && this.modelId > 0) ||
+                            isAuthorizedForSave;
+                    if (this.isAuthorizedForSave) {
+                        this.roleFormGroup.controls.name.enable();
+                        this.roleFormGroup.controls.description.enable();
+                        this.selectedUsersForRole.enable();
+                        this.selectedPermissionsForRole.enable();
+                    }
+                    else {
+                        this.roleFormGroup.controls.name.disable();
+                        this.roleFormGroup.controls.description.disable();
+                        this.selectedUsersForRole.disable();
+                        this.selectedPermissionsForRole.disable();
+                    }
+                    this.onIsAuthorizedForSaveChange.next(new IsAuthorizedForSaveEvent({
+                        isAuthorizedForSave: this.isAuthorizedForSave,
+                        currentUserPermissionCodes: currentUserPermissionCodes
+                    }));
+                }
+            }));
+        };
+    }
+    ngOnInit() {
+        this.formGroup.initSaveBody = () => {
+            let saveBody = new RoleSaveBody();
+            saveBody.roleDTO = this.roleFormGroup.getRawValue();
+            saveBody.selectedPermissionsIds = this.selectedPermissionsForRole.getRawValue();
+            saveBody.selectedUsersIds = this.selectedUsersForRole.getRawValue()?.map(n => n.value);
+            return saveBody;
+        };
+        this.formGroup.saveObservableMethod = this.apiService.saveRole;
+        this.formGroup.mainDTOName = this.roleSaveBodyName;
+        this.route.params.subscribe(async (params) => {
+            this.modelId = params['id'];
+            getPrimengDropdownNamebookOptions(this.apiService.getPermissionsDropdownListForRole).subscribe(po => {
+                this.permissionsForRoleOptions = po;
+            });
+            if (this.modelId > 0) {
+                forkJoin({
+                    mainUIFormDTO: this.apiService.getRoleMainUIFormDTO(this.modelId)
+                })
+                    .subscribe(({ mainUIFormDTO }) => {
+                    this.initRoleFormGroup(new Role(mainUIFormDTO.roleDTO));
+                    this.selectedPermissionsForRole.setValue(mainUIFormDTO.permissionsNamebookDTOList.map(n => { return n.id; }));
+                    this.selectedUsersForRole.setValue(mainUIFormDTO.usersNamebookDTOList.map(n => ({ label: n.displayName, value: n.id })));
+                    this.authorizationForSaveSubscription = this.handleAuthorizationForSave().subscribe();
+                    this.loading = false;
+                });
+            }
+            else {
+                this.initRoleFormGroup(new Role({ id: 0 }));
+                this.authorizationForSaveSubscription = this.handleAuthorizationForSave().subscribe();
+                this.loading = false;
+            }
+        });
+    }
+    initRoleFormGroup(role) {
+        this.baseFormService.addFormGroup(this.roleFormGroup, this.formGroup, role, this.roleSaveBodyName, []);
+        this.roleFormGroup.mainDTOName = this.roleSaveBodyName;
+        this.onRoleFormGroupInitFinish.next();
+    }
+    searchUsersForRole(event) {
+        getPrimengAutocompleteNamebookOptions(this.apiService.getUsersAutocompleteListForRole, 50, event?.query ?? '').subscribe(po => {
+            this.usersForRoleOptions = po;
+        });
+    }
+    control(formControlName, formGroup) {
+        return getControl(formControlName, formGroup);
+    }
+    getFormArrayGroups(formArray) {
+        return this.baseFormService.getFormArrayGroups(formArray);
+    }
+    save() {
+        this.onSave.next();
+    }
+    ngOnDestroy() {
+        if (this.authorizationForSaveSubscription) {
+            this.authorizationForSaveSubscription.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RoleBaseDetailsComponent, deps: [{ token: i1.ApiSecurityService }, { token: i2.ActivatedRoute }, { token: i3.BaseFormService }, { token: i4.AuthBaseService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: RoleBaseDetailsComponent, isStandalone: true, selector: "role-base-details", inputs: { getCrudMenuForOrderedData: "getCrudMenuForOrderedData", formGroup: "formGroup", roleFormGroup: "roleFormGroup", additionalButtons: "additionalButtons", authorizedForSaveObservable: "authorizedForSaveObservable" }, outputs: { onSave: "onSave", onRoleFormGroupInitFinish: "onRoleFormGroupInitFinish", onIsAuthorizedForSaveChange: "onIsAuthorizedForSaveChange" }, ngImport: i0, template: "<ng-container *transloco=\"let t\">\r\n    <spiderly-panel>\r\n        <panel-header></panel-header>\r\n\r\n        <panel-body>\r\n            <form *ngIf=\"loading === false\" class=\"grid\"> <!-- FT: Don't put @deffer it's not working as expected -->\r\n                <div class=\"col-12\">\r\n                    <spiderly-textbox [control]=\"control('name', roleFormGroup)\"></spiderly-textbox>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-textarea [control]=\"control('description', roleFormGroup)\"></spiderly-textarea>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiautocomplete [control]=\"selectedUsersForRole\" [options]=\"usersForRoleOptions\" (onTextInput)=\"searchUsersForRole($event)\" [label]=\"t('Users')\"></spiderly-multiautocomplete>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiselect [control]=\"selectedPermissionsForRole\" [options]=\"permissionsForRoleOptions\" [label]=\"t('Permissions')\"></spiderly-multiselect>\r\n                </div>\r\n            </form>\r\n\r\n            <card-skeleton *ngIf=\"loading === true\" [height]=\"502\"></card-skeleton>\r\n\r\n        </panel-body>\r\n\r\n        <panel-footer>\r\n            <spiderly-button [disabled]=\"!isAuthorizedForSave\" (onClick)=\"save()\" [label]=\"t('Save')\" icon=\"pi pi-save\"></spiderly-button>\r\n            @for (button of additionalButtons; track button.label) {\r\n                <spiderly-button (onClick)=\"button.onClick()\" [disabled]=\"button.disabled\" [label]=\"button.label\" [icon]=\"button.icon\"></spiderly-button>\r\n            }\r\n            <return-button></return-button>\r\n        </panel-footer>\r\n    </spiderly-panel>\r\n</ng-container>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i6.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i6.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i6.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "ngmodule", type: PrimengModule }, { kind: "directive", type: 
+                // SpiderlyControlsModule,
+                TranslocoDirective, selector: "[transloco]", inputs: ["transloco", "translocoParams", "translocoScope", "translocoRead", "translocoPrefix", "translocoLang", "translocoLoadingTpl"] }, { kind: "component", type: CardSkeletonComponent, selector: "card-skeleton", inputs: ["height"] }, { kind: "component", type: SpiderlyTextboxComponent, selector: "spiderly-textbox", inputs: ["showButton", "buttonIcon"], outputs: ["onButtonClick"] }, { kind: "component", type: SpiderlyTextareaComponent, selector: "spiderly-textarea" }, { kind: "component", type: SpiderlyMultiAutocompleteComponent, selector: "spiderly-multiautocomplete" }, { kind: "component", type: SpiderlyMultiSelectComponent, selector: "spiderly-multiselect" }, { kind: "ngmodule", type: SpiderlyPanelsModule }, { kind: "component", type: i7.PanelHeaderComponent, selector: "panel-header", inputs: ["title", "showBigTitle", "showIcon", "icon", "index", "tabs"] }, { kind: "component", type: i8.PanelBodyComponent, selector: "panel-body", inputs: ["normalBottomPadding"] }, { kind: "component", type: i9.PanelFooterComponent, selector: "panel-footer" }, { kind: "component", type: i10.SpiderlyPanelComponent, selector: "spiderly-panel", inputs: ["isFirstMultiplePanel", "isMiddleMultiplePanel", "isLastMultiplePanel", "toggleable", "collapsed", "crudMenu", "showCrudMenu", "showRemoveIcon", "index", "showPanelHeader"], outputs: ["onMenuIconClick", "onRemoveIconClick"] }, { kind: "component", type: SpiderlyButtonComponent, selector: "spiderly-button" }, { kind: "component", type: SpiderlyReturnButtonComponent, selector: "return-button", inputs: ["navigateUrl"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RoleBaseDetailsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'role-base-details', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        PrimengModule,
+                        // SpiderlyControlsModule,
+                        TranslocoDirective,
+                        CardSkeletonComponent,
+                        SpiderlyTextboxComponent,
+                        SpiderlyTextareaComponent,
+                        SpiderlyMultiAutocompleteComponent,
+                        SpiderlyMultiSelectComponent,
+                        SpiderlyPanelsModule,
+                        SpiderlyButtonComponent,
+                        SpiderlyReturnButtonComponent
+                    ], template: "<ng-container *transloco=\"let t\">\r\n    <spiderly-panel>\r\n        <panel-header></panel-header>\r\n\r\n        <panel-body>\r\n            <form *ngIf=\"loading === false\" class=\"grid\"> <!-- FT: Don't put @deffer it's not working as expected -->\r\n                <div class=\"col-12\">\r\n                    <spiderly-textbox [control]=\"control('name', roleFormGroup)\"></spiderly-textbox>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-textarea [control]=\"control('description', roleFormGroup)\"></spiderly-textarea>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiautocomplete [control]=\"selectedUsersForRole\" [options]=\"usersForRoleOptions\" (onTextInput)=\"searchUsersForRole($event)\" [label]=\"t('Users')\"></spiderly-multiautocomplete>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiselect [control]=\"selectedPermissionsForRole\" [options]=\"permissionsForRoleOptions\" [label]=\"t('Permissions')\"></spiderly-multiselect>\r\n                </div>\r\n            </form>\r\n\r\n            <card-skeleton *ngIf=\"loading === true\" [height]=\"502\"></card-skeleton>\r\n\r\n        </panel-body>\r\n\r\n        <panel-footer>\r\n            <spiderly-button [disabled]=\"!isAuthorizedForSave\" (onClick)=\"save()\" [label]=\"t('Save')\" icon=\"pi pi-save\"></spiderly-button>\r\n            @for (button of additionalButtons; track button.label) {\r\n                <spiderly-button (onClick)=\"button.onClick()\" [disabled]=\"button.disabled\" [label]=\"button.label\" [icon]=\"button.icon\"></spiderly-button>\r\n            }\r\n            <return-button></return-button>\r\n        </panel-footer>\r\n    </spiderly-panel>\r\n</ng-container>" }]
+        }], ctorParameters: () => [{ type: i1.ApiSecurityService }, { type: i2.ActivatedRoute }, { type: i3.BaseFormService }, { type: i4.AuthBaseService }], propDecorators: { onSave: [{
+                type: Output
+            }], onRoleFormGroupInitFinish: [{
+                type: Output
+            }], getCrudMenuForOrderedData: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }], roleFormGroup: [{
+                type: Input
+            }], additionalButtons: [{
+                type: Input
+            }], authorizedForSaveObservable: [{
+                type: Input
+            }], onIsAuthorizedForSaveChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role-base-details.component.js","sourceRoot":"","sources":["../../../../../../projects/spiderly/src/lib/components/base-details/role-base-details.component.ts","../../../../../../projects/spiderly/src/lib/components/base-details/role-base-details.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { Component, EventEmitter, Input, Output } from '@angular/core';\r\nimport { TranslocoDirective } from '@jsverse/transloco';\r\nimport { ActivatedRoute } from '@angular/router';\r\nimport { combineLatest, forkJoin, map, Observable, of, Subscription } from 'rxjs';\r\nimport { MenuItem } from 'primeng/api';\r\nimport { PrimengModule } from '../../modules/primeng.module';\r\nimport { SpiderlyControlsModule } from '../../controls/spiderly-controls.module';\r\nimport { CardSkeletonComponent } from '../card-skeleton/card-skeleton.component';\r\nimport { SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup } from '../spiderly-form-control/spiderly-form-control';\r\nimport { BaseEntity } from '../../entities/base-entity';\r\nimport { LastMenuIconIndexClicked } from '../../entities/last-menu-icon-index-clicked';\r\nimport { Role, RoleSaveBody } from '../../entities/security-entities';\r\nimport { SpiderlyButton } from '../../entities/spiderly-button';\r\nimport { getControl, getPrimengAutocompleteNamebookOptions, getPrimengDropdownNamebookOptions, nameof } from '../../services/helper-functions';\r\nimport { BaseFormService } from '../../services/base-form.service';\r\nimport { ApiSecurityService } from '../../services/api.service.security';\r\nimport { PrimengOption } from '../../entities/primeng-option';\r\nimport { AutoCompleteCompleteEvent } from 'primeng/autocomplete';\r\nimport { IsAuthorizedForSaveEvent } from '../../entities/is-authorized-for-save-event';\r\nimport { AuthBaseService } from '../../services/auth-base.service';\r\nimport { SpiderlyTextboxComponent } from '../../controls/spiderly-textbox/spiderly-textbox.component';\r\nimport { SpiderlyTextareaComponent } from '../../controls/spiderly-textarea/spiderly-textarea.component';\r\nimport { SpiderlyMultiAutocompleteComponent } from '../../controls/spiderly-multiautocomplete/spiderly-multiautocomplete.component';\r\nimport { SpiderlyMultiSelectComponent } from '../../controls/spiderly-multiselect/spiderly-multiselect.component';\r\nimport { SpiderlyPanelsModule } from '../spiderly-panels/spiderly-panels.module';\r\nimport { SpiderlyButtonComponent } from '../spiderly-buttons/spiderly-button/spiderly-button.component';\r\nimport { SpiderlyReturnButtonComponent } from '../spiderly-buttons/return-button/return-button.component';\r\n\r\n@Component({\r\n    selector: 'role-base-details',\r\n    templateUrl: 'role-base-details.component.html',\r\n    standalone: true,\r\n    imports: [\r\n        CommonModule, \r\n        FormsModule,\r\n        ReactiveFormsModule,\r\n        PrimengModule,\r\n        // SpiderlyControlsModule,\r\n        TranslocoDirective,\r\n        CardSkeletonComponent,\r\n        SpiderlyTextboxComponent,\r\n        SpiderlyTextareaComponent,\r\n        SpiderlyMultiAutocompleteComponent,\r\n        SpiderlyMultiSelectComponent,\r\n        SpiderlyPanelsModule,\r\n        SpiderlyButtonComponent,\r\n        SpiderlyReturnButtonComponent\r\n    ]\r\n})\r\nexport class RoleBaseDetailsComponent {\r\n    @Output() onSave = new EventEmitter<void>();\r\n    @Output() onRoleFormGroupInitFinish = new EventEmitter<void>();\r\n    @Input() getCrudMenuForOrderedData: (formArray: SpiderlyFormArray, modelConstructor: BaseEntity, lastMenuIconIndexClicked: LastMenuIconIndexClicked, adjustFormArrayManually: boolean) => MenuItem[];\r\n    @Input() formGroup: SpiderlyFormGroup;\r\n    @Input() roleFormGroup: SpiderlyFormGroup<Role>;\r\n    @Input() additionalButtons: SpiderlyButton[] = [];\r\n\r\n    authorizationForSaveSubscription: Subscription;\r\n    @Input() authorizedForSaveObservable: () => Observable<boolean> = () => of(false);\r\n    isAuthorizedForSave: boolean = false;\r\n    @Output() onIsAuthorizedForSaveChange = new EventEmitter<IsAuthorizedForSaveEvent>(); \r\n    \r\n    modelId: number;\r\n    loading: boolean = true;\r\n    roleSaveBodyName: string = nameof<RoleSaveBody>('roleDTO');\r\n\r\n    usersForRoleOptions: PrimengOption[];\r\n    permissionsForRoleOptions: PrimengOption[];\r\n\r\n    selectedUsersForRole = new SpiderlyFormControl<PrimengOption[]>(null, {updateOn: 'change'});\r\n    selectedPermissionsForRole = new SpiderlyFormControl<number[]>(null, {updateOn: 'change'});\r\n\r\n    constructor(\r\n        private apiService: ApiSecurityService,\r\n        private route: ActivatedRoute,\r\n        private baseFormService: BaseFormService,\r\n        private authService: AuthBaseService\r\n    ) {}\r\n\r\n    ngOnInit(){\r\n        this.formGroup.initSaveBody = () => { \r\n            let saveBody = new RoleSaveBody();\r\n            saveBody.roleDTO = this.roleFormGroup.getRawValue();\r\n\r\n            saveBody.selectedPermissionsIds = this.selectedPermissionsForRole.getRawValue();\r\n            saveBody.selectedUsersIds = this.selectedUsersForRole.getRawValue()?.map(n => n.value);\r\n\r\n            return saveBody;\r\n        }\r\n\r\n        this.formGroup.saveObservableMethod = this.apiService.saveRole;\r\n        this.formGroup.mainDTOName = this.roleSaveBodyName;\r\n\r\n        this.route.params.subscribe(async (params) => {\r\n            this.modelId = params['id'];\r\n\r\n            getPrimengDropdownNamebookOptions(this.apiService.getPermissionsDropdownListForRole).subscribe(po => {\r\n                this.permissionsForRoleOptions = po;\r\n            });\r\n\r\n            if(this.modelId > 0){\r\n                forkJoin({\r\n                    mainUIFormDTO: this.apiService.getRoleMainUIFormDTO(this.modelId)\r\n                })\r\n                .subscribe(({ mainUIFormDTO }) => {\r\n                    this.initRoleFormGroup(new Role(mainUIFormDTO.roleDTO));\r\n\r\n                    this.selectedPermissionsForRole.setValue(\r\n                        mainUIFormDTO.permissionsNamebookDTOList.map(n => { return n.id })\r\n                    );\r\n                    this.selectedUsersForRole.setValue(\r\n                        mainUIFormDTO.usersNamebookDTOList.map(n => ({ label: n.displayName, value: n.id }))\r\n                    );\r\n\r\n                    this.authorizationForSaveSubscription = this.handleAuthorizationForSave().subscribe();\r\n                    this.loading = false;\r\n                });\r\n            }\r\n            else{\r\n                this.initRoleFormGroup(new Role({id: 0}));\r\n\r\n                this.authorizationForSaveSubscription = this.handleAuthorizationForSave().subscribe();\r\n                this.loading = false;\r\n            }\r\n        });\r\n    }\r\n\r\n    initRoleFormGroup(role: Role) {\r\n        this.baseFormService.addFormGroup<Role>(\r\n            this.roleFormGroup, \r\n            this.formGroup, \r\n            role, \r\n            this.roleSaveBodyName,\r\n            []\r\n        );\r\n        this.roleFormGroup.mainDTOName = this.roleSaveBodyName;\r\n        this.onRoleFormGroupInitFinish.next();\r\n    }\r\n    \r\n    handleAuthorizationForSave = () => {\r\n        return combineLatest([this.authService.currentUserPermissionCodes$, this.authorizedForSaveObservable()]).pipe(\r\n            map(([currentUserPermissionCodes, isAuthorizedForSave]) => {\r\n                if (currentUserPermissionCodes != null && isAuthorizedForSave != null) {\r\n                    this.isAuthorizedForSave =\r\n                        (currentUserPermissionCodes.includes('InsertRole') && this.modelId <= 0) || \r\n                        (currentUserPermissionCodes.includes('UpdateRole') && this.modelId > 0) ||\r\n                        isAuthorizedForSave;\r\n\r\n                    if (this.isAuthorizedForSave) { \r\n                        this.roleFormGroup.controls.name.enable();\r\n                        this.roleFormGroup.controls.description.enable();\r\n                        this.selectedUsersForRole.enable();\r\n                        this.selectedPermissionsForRole.enable();\r\n                    }\r\n                    else{\r\n                        this.roleFormGroup.controls.name.disable();\r\n                        this.roleFormGroup.controls.description.disable();\r\n                        this.selectedUsersForRole.disable();\r\n                        this.selectedPermissionsForRole.disable();\r\n                    }\r\n\r\n                    this.onIsAuthorizedForSaveChange.next(new IsAuthorizedForSaveEvent({\r\n                        isAuthorizedForSave: this.isAuthorizedForSave, \r\n                        currentUserPermissionCodes: currentUserPermissionCodes\r\n                    })); \r\n                }\r\n            })\r\n        );\r\n    }\r\n\r\n    searchUsersForRole(event: AutoCompleteCompleteEvent) {\r\n        getPrimengAutocompleteNamebookOptions(this.apiService.getUsersAutocompleteListForRole, 50, event?.query ?? '').subscribe(po => {\r\n            this.usersForRoleOptions = po;\r\n        });\r\n    }\r\n\r\n    control(formControlName: string, formGroup: SpiderlyFormGroup){\r\n        return getControl(formControlName, formGroup);\r\n    }\r\n\r\n    getFormArrayGroups<T>(formArray: SpiderlyFormArray): SpiderlyFormGroup<T>[]{\r\n        return this.baseFormService.getFormArrayGroups<T>(formArray);\r\n    }\r\n\r\n    save(){\r\n        this.onSave.next();\r\n    }\r\n\r\n    ngOnDestroy(){\r\n        if (this.authorizationForSaveSubscription) {\r\n            this.authorizationForSaveSubscription.unsubscribe();\r\n        }\r\n    }\r\n\r\n}\r\n","<ng-container *transloco=\"let t\">\r\n    <spiderly-panel>\r\n        <panel-header></panel-header>\r\n\r\n        <panel-body>\r\n            <form *ngIf=\"loading === false\" class=\"grid\"> <!-- FT: Don't put @deffer it's not working as expected -->\r\n                <div class=\"col-12\">\r\n                    <spiderly-textbox [control]=\"control('name', roleFormGroup)\"></spiderly-textbox>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-textarea [control]=\"control('description', roleFormGroup)\"></spiderly-textarea>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiautocomplete [control]=\"selectedUsersForRole\" [options]=\"usersForRoleOptions\" (onTextInput)=\"searchUsersForRole($event)\" [label]=\"t('Users')\"></spiderly-multiautocomplete>\r\n                </div>\r\n                <div class=\"col-12\">\r\n                    <spiderly-multiselect [control]=\"selectedPermissionsForRole\" [options]=\"permissionsForRoleOptions\" [label]=\"t('Permissions')\"></spiderly-multiselect>\r\n                </div>\r\n            </form>\r\n\r\n            <card-skeleton *ngIf=\"loading === true\" [height]=\"502\"></card-skeleton>\r\n\r\n        </panel-body>\r\n\r\n        <panel-footer>\r\n            <spiderly-button [disabled]=\"!isAuthorizedForSave\" (onClick)=\"save()\" [label]=\"t('Save')\" icon=\"pi pi-save\"></spiderly-button>\r\n            @for (button of additionalButtons; track button.label) {\r\n                <spiderly-button (onClick)=\"button.onClick()\" [disabled]=\"button.disabled\" [label]=\"button.label\" [icon]=\"button.icon\"></spiderly-button>\r\n            }\r\n            <return-button></return-button>\r\n        </panel-footer>\r\n    </spiderly-panel>\r\n</ng-container>"]}

package/esm2022/lib/components/base-form/base-form copy.mjs

@@ -0,0 +1,247 @@
+import { Component, } from '@angular/core';
+import { SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup } from '../spiderly-form-control/spiderly-form-control';
+import { getControl, getParentUrl } from '../../services/helper-functions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../services/spiderly-message.service";
+import * as i3 from "@angular/router";
+import * as i4 from "@jsverse/transloco";
+import * as i5 from "./../../services/base-form.service";
+export class BaseFormCopy {
+    constructor(differs, http, messageService, changeDetectorRef, router, route, translocoService, baseFormService) {
+        this.differs = differs;
+        this.http = http;
+        this.messageService = messageService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.router = router;
+        this.route = route;
+        this.translocoService = translocoService;
+        this.baseFormService = baseFormService;
+        this.formGroup = new SpiderlyFormGroup({});
+        this.successfulSaveToastDescription = this.translocoService.translate('SuccessfulSaveToastDescription');
+        this.loading = true;
+        //#region Model
+        this.initFormGroup = (formGroup, parentFormGroup, modelConstructor, propertyNameInSaveBody, updateOnChangeControls) => {
+            return this.baseFormService.addFormGroup(formGroup, parentFormGroup, modelConstructor, propertyNameInSaveBody, updateOnChangeControls);
+        };
+        this.createFormGroup = (formGroup, modelConstructor, updateOnChangeControls) => {
+            return this.baseFormService.initFormGroup(formGroup, modelConstructor, updateOnChangeControls);
+        };
+        this.control = (formControlName, formGroup) => {
+            return getControl(formControlName, formGroup);
+        };
+        this.onSave = (reroute = true) => {
+            this.saveBody = this.formGroup.initSaveBody();
+            this.onBeforeSave(this.saveBody);
+            this.saveBody = this.saveBody ?? this.formGroup.getRawValue();
+            let isValid = this.areFormGroupsFromParentFormGroupValid();
+            let isFormArrayValid = this.areFormArraysValid();
+            if (isValid && isFormArrayValid) {
+                this.formGroup.saveObservableMethod(this.saveBody).subscribe(res => {
+                    this.messageService.successMessage(this.successfulSaveToastDescription);
+                    Object.keys(res).forEach((key) => {
+                        const formControl = this.formGroup.get(key);
+                        if (formControl) {
+                            if (formControl instanceof SpiderlyFormArray) {
+                                const formArray = formControl;
+                                if (res[key].length !== 0) {
+                                    formArray.clear();
+                                }
+                                else {
+                                    // FT: This is okay because when we have M2M association with additional fields, we will not give back the list because we are not checking version on the server.
+                                    // console.error(`You returned empty array for control: ${formArray.translationKey}.`);
+                                }
+                                res[key].forEach((model) => {
+                                    if (typeof model === 'object' && model !== null) {
+                                        Object.assign(formArray.modelConstructor, model);
+                                        let helperFormGroup = new SpiderlyFormGroup({});
+                                        this.baseFormService.initFormGroup(helperFormGroup, formArray.modelConstructor);
+                                        formArray.push(helperFormGroup);
+                                    }
+                                    else {
+                                        console.error('Can not add primitive form control inside form array.');
+                                    }
+                                });
+                            }
+                            else {
+                                formControl.patchValue(res[key]);
+                            }
+                        }
+                        else {
+                            // FT: It's okay to do this.
+                            // console.error('You returned something that is not in the save DTO.');
+                        }
+                    });
+                    if (reroute) {
+                        const savedObjectId = res[this.formGroup.mainDTOName]?.id;
+                        this.rerouteToSavedObject(savedObjectId); // You always need to have id, because of id == 0 and version change
+                    }
+                    this.onAfterSave();
+                });
+                this.onAfterSaveRequest();
+            }
+            else {
+                this.baseFormService.showInvalidFieldsMessage();
+            }
+        };
+        this.rerouteToSavedObject = (rerouteId) => {
+            if (rerouteId == null) {
+                // console.error('You do not have rerouteId in your DTO.')
+                const currentUrl = this.router.url;
+                const parentUrl = getParentUrl(currentUrl);
+                this.router.navigateByUrl(parentUrl);
+                return;
+            }
+            const segments = this.router.url.split('/');
+            segments[segments.length - 1] = rerouteId.toString();
+            const newUrl = segments.join('/');
+            this.router.navigateByUrl(newUrl);
+        };
+        this.onBeforeSave = (saveBody) => { };
+        this.onAfterSave = () => { };
+        this.onAfterSaveRequest = () => { };
+        // FT: Sending LastMenuIconIndexClicked class because of reference type
+        this.getCrudMenuForOrderedData = (formArray, modelConstructor, lastMenuIconIndexClicked, adjustFormArrayManually = false) => {
+            let crudMenuForOrderedData = [
+                { label: this.translocoService.translate('Remove'), icon: 'pi pi-minus', command: () => {
+                        this.onBeforeRemove(formArray, modelConstructor, lastMenuIconIndexClicked.index);
+                        if (adjustFormArrayManually === false) {
+                            this.removeFormControlFromTheFormArray(formArray, lastMenuIconIndexClicked.index);
+                        }
+                    } },
+                { label: this.translocoService.translate('AddAbove'), icon: 'pi pi-arrow-up', command: () => {
+                        this.onBeforeAddAbove(formArray, modelConstructor, lastMenuIconIndexClicked.index);
+                        if (adjustFormArrayManually === false) {
+                            this.baseFormService.addNewFormGroupToFormArray(formArray, modelConstructor, lastMenuIconIndexClicked.index);
+                        }
+                    } },
+                { label: this.translocoService.translate('AddBelow'), icon: 'pi pi-arrow-down', command: () => {
+                        this.onBeforeAddBelow(formArray, modelConstructor, lastMenuIconIndexClicked.index);
+                        if (adjustFormArrayManually === false) {
+                            this.baseFormService.addNewFormGroupToFormArray(formArray, modelConstructor, lastMenuIconIndexClicked.index + 1);
+                        }
+                    } },
+            ];
+            return crudMenuForOrderedData;
+        };
+        this.onBeforeRemove = (formArray, modelConstructor, lastMenuIconIndexClicked) => { };
+        this.onBeforeAddAbove = (formArray, modelConstructor, lastMenuIconIndexClicked) => { };
+        this.onBeforeAddBelow = (formArray, modelConstructor, lastMenuIconIndexClicked) => { };
+    }
+    ngOnInit() {
+    }
+    areFormGroupsFromParentFormGroupValid() {
+        if (this.formGroup.controls == null)
+            return true;
+        let invalid = false;
+        Object.keys(this.formGroup.controls).forEach(key => {
+            const formGroupOrControl = this.formGroup.controls[key];
+            if (formGroupOrControl instanceof SpiderlyFormGroup) {
+                Object.keys(formGroupOrControl.controls).forEach(key => {
+                    const formControl = formGroupOrControl.controls[key]; // this.formArray.markAsDirty(); // FT: For some reason this doesnt work
+                    if (formGroupOrControl.controlNamesFromHtml.includes(formControl.label) && formControl.invalid) {
+                        formControl.markAsDirty();
+                        invalid = true;
+                    }
+                });
+            }
+            else if (formGroupOrControl instanceof SpiderlyFormControl) {
+                if (formGroupOrControl.invalid) {
+                    formGroupOrControl.markAsDirty();
+                    invalid = true;
+                }
+            }
+        });
+        if (invalid) {
+            return false;
+        }
+        return true;
+    }
+    //#endregion
+    //#region Model List
+    getFormArrayControlByIndex(formControlName, formArray, index, filter) {
+        if (formArray.controlNamesFromHtml.findIndex(x => x === formControlName) === -1)
+            formArray.controlNamesFromHtml.push(formControlName);
+        let filteredFormGroups;
+        if (filter) {
+            filteredFormGroups = filter(formArray.controls);
+        }
+        else {
+            return formArray.controls[index].controls[formControlName];
+        }
+        return filteredFormGroups[index]?.controls[formControlName]; // FT: Don't change this. It's always possible that change detection occurs before something.
+    }
+    getFormArrayControls(formControlName, formArray, filter) {
+        if (formArray.controlNamesFromHtml.findIndex(x => x === formControlName) === -1)
+            formArray.controlNamesFromHtml.push(formControlName);
+        let filteredFormGroups;
+        if (filter) {
+            filteredFormGroups = filter(formArray.controls);
+        }
+        else {
+            return formArray.controls.map(x => x.controls[formControlName]);
+        }
+        return filteredFormGroups.map(x => x.controls[formControlName]);
+    }
+    getFormArrayGroups(formArray) {
+        return this.baseFormService.getFormArrayGroups(formArray);
+    }
+    addNewFormGroupToFormArray(formArray, modelConstructor, index) {
+        return this.baseFormService.addNewFormGroupToFormArray(formArray, modelConstructor, index);
+    }
+    initFormArray(parentFormGroup, modelList, modelConstructor, formArraySaveBodyName, formArrayTranslationKey, required = false) {
+        return this.baseFormService.initFormArray(parentFormGroup, modelList, modelConstructor, formArraySaveBodyName, formArrayTranslationKey, required);
+    }
+    removeFormControlFromTheFormArray(formArray, index) {
+        if (index == null)
+            throw new Error('Can not pass null index.');
+        formArray.removeAt(index);
+    }
+    removeFormControlsFromTheFormArray(formArray, indexes) {
+        // Sort indexes in descending order to avoid index shifts when removing controls
+        const sortedIndexes = indexes.sort((a, b) => b - a);
+        sortedIndexes.forEach(index => {
+            if (index >= 0 && index < formArray.length) {
+                formArray.removeAt(index);
+            }
+        });
+    }
+    areFormArraysValid() {
+        if (this.formGroup.controls == null)
+            return true;
+        let invalid = false;
+        Object.keys(this.formGroup.controls).forEach(key => {
+            const formArray = this.formGroup.controls[key];
+            if (formArray instanceof SpiderlyFormArray) {
+                formArray.controls.forEach(formGroup => {
+                    Object.keys(formGroup.controls).forEach(key => {
+                        const formControl = formGroup.controls[key]; // this.formArray.markAsDirty(); // FT: For some reason this doesn't work
+                        if ((formGroup.controlNamesFromHtml.includes(formControl.label) || formArray.controlNamesFromHtml.includes(formControl.label)) &&
+                            formControl.invalid) {
+                            formControl.markAsDirty();
+                            invalid = true;
+                        }
+                    });
+                });
+                if (formArray.required == true && formArray.length == 0) {
+                    invalid = true;
+                    this.messageService.warningMessage(this.translocoService.translate('ListCanNotBeEmpty'));
+                }
+            }
+        });
+        if (invalid) {
+            return false;
+        }
+        return true;
+    }
+    onBeforeSaveList() { }
+    onAfterSaveList() { }
+    onAfterSaveListRequest() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseFormCopy, deps: [{ token: i0.KeyValueDiffers }, { token: i1.HttpClient }, { token: i2.SpiderlyMessageService }, { token: i0.ChangeDetectorRef }, { token: i3.Router }, { token: i3.ActivatedRoute }, { token: i4.TranslocoService }, { token: i5.BaseFormService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: BaseFormCopy, selector: "base-form", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseFormCopy, decorators: [{
+            type: Component,
+            args: [{ selector: 'base-form', template: '' }]
+        }], ctorParameters: () => [{ type: i0.KeyValueDiffers }, { type: i1.HttpClient }, { type: i2.SpiderlyMessageService }, { type: i0.ChangeDetectorRef }, { type: i3.Router }, { type: i3.ActivatedRoute }, { type: i4.TranslocoService }, { type: i5.BaseFormService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-form copy.js","sourceRoot":"","sources":["../../../../../../projects/spiderly/src/lib/components/base-form/base-form copy.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseFormService } from './../../services/base-form.service';\r\nimport {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  KeyValueDiffer,\r\n  KeyValueDiffers,\r\n  OnInit,\r\n} from '@angular/core';\r\nimport { SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup } from '../spiderly-form-control/spiderly-form-control';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { SpiderlyMessageService } from '../../services/spiderly-message.service';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { MenuItem } from 'primeng/api';\r\nimport { getControl, getParentUrl } from '../../services/helper-functions';\r\nimport { TranslocoService } from '@jsverse/transloco';\r\nimport { BaseEntity } from '../../entities/base-entity';\r\nimport { LastMenuIconIndexClicked } from '../../entities/last-menu-icon-index-clicked';\r\n\r\n@Component({\r\n  selector: 'base-form',\r\n  template: '',\r\n  styles: [],\r\n})\r\nexport class BaseFormCopy implements OnInit { \r\n  formGroup: SpiderlyFormGroup = new SpiderlyFormGroup({});\r\n  saveBody: any;\r\n  successfulSaveToastDescription: string = this.translocoService.translate('SuccessfulSaveToastDescription');\r\n  loading: boolean = true;\r\n\r\n  private modelDiffer: KeyValueDiffer<string, any>;\r\n\r\n  constructor(\r\n    protected differs: KeyValueDiffers, \r\n    protected http: HttpClient, \r\n    protected messageService: SpiderlyMessageService, \r\n    protected changeDetectorRef: ChangeDetectorRef,\r\n    protected router: Router, \r\n    protected route: ActivatedRoute,\r\n    protected translocoService: TranslocoService,\r\n    protected baseFormService: BaseFormService,\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(){\r\n  }\r\n\r\n  //#region Model\r\n\r\n  initFormGroup = <T>(\r\n    formGroup: SpiderlyFormGroup<T>, \r\n    parentFormGroup: SpiderlyFormGroup, \r\n    modelConstructor: any, \r\n    propertyNameInSaveBody: string,\r\n    updateOnChangeControls?: (keyof T)[]\r\n  ) => {\r\n    return this.baseFormService.addFormGroup(\r\n      formGroup, parentFormGroup, modelConstructor, propertyNameInSaveBody, updateOnChangeControls\r\n    );\r\n  }\r\n\r\n  createFormGroup = <T>(\r\n    formGroup: SpiderlyFormGroup<T>, \r\n    modelConstructor: T & BaseEntity, \r\n    updateOnChangeControls?: (keyof T)[]\r\n  ) => {\r\n    return this.baseFormService.initFormGroup(\r\n      formGroup, modelConstructor, updateOnChangeControls\r\n    );\r\n  }\r\n\r\n  control = <T extends BaseEntity>(formControlName: string & keyof T, formGroup: SpiderlyFormGroup<T>) => {\r\n    return getControl(formControlName, formGroup);\r\n  }\r\n\r\n  onSave = (reroute: boolean = true) => {\r\n    this.saveBody = this.formGroup.initSaveBody();\r\n    this.onBeforeSave(this.saveBody);\r\n\r\n    this.saveBody = this.saveBody ?? this.formGroup.getRawValue();\r\n\r\n    let isValid: boolean = this.areFormGroupsFromParentFormGroupValid();\r\n    let isFormArrayValid: boolean = this.areFormArraysValid();\r\n\r\n    if(isValid && isFormArrayValid){\r\n      this.formGroup.saveObservableMethod(this.saveBody).subscribe(res => {\r\n        this.messageService.successMessage(this.successfulSaveToastDescription);\r\n\r\n        Object.keys(res).forEach((key) => {\r\n          const formControl = this.formGroup.get(key);\r\n          \r\n          if (formControl) {\r\n            if (formControl instanceof SpiderlyFormArray) {\r\n              const formArray = formControl as SpiderlyFormArray;\r\n              if (res[key].length !== 0) {\r\n                formArray.clear();\r\n              }\r\n              else{\r\n                // FT: This is okay because when we have M2M association with additional fields, we will not give back the list because we are not checking version on the server.\r\n                // console.error(`You returned empty array for control: ${formArray.translationKey}.`);\r\n              }\r\n\r\n              res[key].forEach((model: any) => {\r\n                if (typeof model === 'object' && model !== null) {\r\n                  Object.assign(formArray.modelConstructor, model);\r\n                  let helperFormGroup = new SpiderlyFormGroup({});\r\n                  this.baseFormService.initFormGroup(helperFormGroup, formArray.modelConstructor)\r\n                  formArray.push(helperFormGroup);\r\n                } else {\r\n                  console.error('Can not add primitive form control inside form array.');\r\n                }\r\n              });\r\n\r\n            } else {\r\n              formControl.patchValue(res[key]);\r\n            }\r\n          }else{\r\n            // FT: It's okay to do this.\r\n            // console.error('You returned something that is not in the save DTO.');\r\n          }\r\n        });\r\n\r\n        if (reroute) {\r\n          const savedObjectId = (res as any)[this.formGroup.mainDTOName]?.id;\r\n          this.rerouteToSavedObject(savedObjectId); // You always need to have id, because of id == 0 and version change\r\n        }\r\n        \r\n        this.onAfterSave();\r\n      });\r\n      \r\n      this.onAfterSaveRequest();\r\n    }else{\r\n      this.baseFormService.showInvalidFieldsMessage();\r\n    }\r\n  }\r\n\r\n  rerouteToSavedObject = (rerouteId: number | string): void => {\r\n    if(rerouteId == null){\r\n      // console.error('You do not have rerouteId in your DTO.')\r\n      const currentUrl = this.router.url;\r\n      const parentUrl: string = getParentUrl(currentUrl);\r\n      this.router.navigateByUrl(parentUrl);\r\n      return;\r\n    }\r\n      \r\n    const segments = this.router.url.split('/');\r\n    segments[segments.length - 1] = rerouteId.toString();\r\n\r\n    const newUrl = segments.join('/');\r\n    this.router.navigateByUrl(newUrl);\r\n  }\r\n\r\n  onBeforeSave = (saveBody?: any) => {}\r\n  onAfterSave = () => {}\r\n  onAfterSaveRequest = () => {}\r\n\r\n  areFormGroupsFromParentFormGroupValid(): boolean {\r\n    if(this.formGroup.controls == null)\r\n      return true;\r\n\r\n    let invalid: boolean = false;\r\n\r\n    Object.keys(this.formGroup.controls).forEach(key => {\r\n      const formGroupOrControl = this.formGroup.controls[key];\r\n\r\n      if (formGroupOrControl instanceof SpiderlyFormGroup){\r\n        Object.keys(formGroupOrControl.controls).forEach(key => {\r\n          const formControl = formGroupOrControl.controls[key] as SpiderlyFormControl; // this.formArray.markAsDirty(); // FT: For some reason this doesnt work\r\n\r\n          if (formGroupOrControl.controlNamesFromHtml.includes(formControl.label) && formControl.invalid) {\r\n            formControl.markAsDirty();\r\n            invalid = true;\r\n          }\r\n        });\r\n      }\r\n      else if (formGroupOrControl instanceof SpiderlyFormControl){\r\n        if (formGroupOrControl.invalid) {\r\n          formGroupOrControl.markAsDirty();\r\n          invalid = true;\r\n        }\r\n      }\r\n\r\n    });\r\n\r\n    if (invalid) {\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  //#endregion\r\n\r\n  //#region Model List\r\n  \r\n  getFormArrayControlByIndex<T>(formControlName: keyof T & string, formArray: SpiderlyFormArray<T>, index: number, filter?: (formGroups: SpiderlyFormGroup<T>[]) => SpiderlyFormGroup<T>[]): SpiderlyFormControl {\r\n    if(formArray.controlNamesFromHtml.findIndex(x => x === formControlName) === -1)\r\n      formArray.controlNamesFromHtml.push(formControlName);\r\n\r\n    let filteredFormGroups: SpiderlyFormGroup<T>[];\r\n\r\n    if (filter) {\r\n      filteredFormGroups = filter(formArray.controls as SpiderlyFormGroup<T>[]);\r\n    }\r\n    else{\r\n      return (formArray.controls[index] as SpiderlyFormGroup<T>).controls[formControlName] as SpiderlyFormControl;\r\n    }\r\n\r\n    return filteredFormGroups[index]?.controls[formControlName] as SpiderlyFormControl; // FT: Don't change this. It's always possible that change detection occurs before something.\r\n  }\r\n\r\n  getFormArrayControls<T>(formControlName: keyof T & string, formArray: SpiderlyFormArray<T>, filter?: (formGroups: SpiderlyFormGroup<T>[]) => SpiderlyFormGroup<T>[]): SpiderlyFormControl[] {\r\n    if(formArray.controlNamesFromHtml.findIndex(x => x === formControlName) === -1)\r\n      formArray.controlNamesFromHtml.push(formControlName);\r\n\r\n    let filteredFormGroups: SpiderlyFormGroup<T>[];\r\n\r\n    if (filter) {\r\n      filteredFormGroups = filter(formArray.controls as SpiderlyFormGroup<T>[]);\r\n    }\r\n    else{\r\n      return (formArray.controls as SpiderlyFormGroup<T>[]).map(x => x.controls[formControlName] as SpiderlyFormControl);\r\n    }\r\n\r\n    return filteredFormGroups.map(x => x.controls[formControlName] as SpiderlyFormControl);\r\n  }\r\n\r\n  getFormArrayGroups<T>(formArray: SpiderlyFormArray<T>): SpiderlyFormGroup<T>[]{\r\n    return this.baseFormService.getFormArrayGroups(formArray);\r\n  }\r\n\r\n  addNewFormGroupToFormArray<T>(\r\n    formArray: SpiderlyFormArray<T>, \r\n    modelConstructor: T & BaseEntity,\r\n    index: number,\r\n  ) : SpiderlyFormGroup {\r\n    return this.baseFormService.addNewFormGroupToFormArray(formArray, modelConstructor, index)\r\n  }\r\n\r\n  initFormArray<T>(\r\n    parentFormGroup: SpiderlyFormGroup, \r\n    modelList: (T & BaseEntity)[], \r\n    modelConstructor: T & BaseEntity, \r\n    formArraySaveBodyName: string, \r\n    formArrayTranslationKey: string, \r\n    required: boolean = false)\r\n  {\r\n    return this.baseFormService.initFormArray<T>(\r\n      parentFormGroup, modelList, modelConstructor, formArraySaveBodyName, formArrayTranslationKey, required\r\n    );\r\n  }\r\n\r\n  removeFormControlFromTheFormArray(formArray: SpiderlyFormArray, index: number) {\r\n    if(index == null)\r\n      throw new Error('Can not pass null index.');\r\n\r\n    formArray.removeAt(index);\r\n  }\r\n\r\n  removeFormControlsFromTheFormArray(formArray: SpiderlyFormArray, indexes: number[]) {\r\n    // Sort indexes in descending order to avoid index shifts when removing controls\r\n    const sortedIndexes = indexes.sort((a, b) => b - a);\r\n\r\n    sortedIndexes.forEach(index => {\r\n      if (index >= 0 && index < formArray.length) {\r\n        formArray.removeAt(index);\r\n      }\r\n    });\r\n  }\r\n\r\n  areFormArraysValid(): boolean {\r\n    if(this.formGroup.controls == null)\r\n      return true;\r\n\r\n    let invalid: boolean = false;\r\n\r\n    Object.keys(this.formGroup.controls).forEach(key => {\r\n      const formArray = this.formGroup.controls[key] as unknown as SpiderlyFormArray;\r\n      \r\n      if (formArray instanceof SpiderlyFormArray){\r\n        (formArray.controls as SpiderlyFormGroup[]).forEach(formGroup => {\r\n          Object.keys(formGroup.controls).forEach(key => {\r\n            const formControl = formGroup.controls[key] as SpiderlyFormControl; // this.formArray.markAsDirty(); // FT: For some reason this doesn't work\r\n\r\n            if (\r\n              (formGroup.controlNamesFromHtml.includes(formControl.label) || formArray.controlNamesFromHtml.includes(formControl.label)) && \r\n              formControl.invalid\r\n            ) {\r\n              formControl.markAsDirty();\r\n              invalid = true;\r\n            }\r\n          });\r\n        });\r\n\r\n        if (formArray.required == true && formArray.length == 0) {\r\n          invalid = true;\r\n          this.messageService.warningMessage(this.translocoService.translate('ListCanNotBeEmpty'));\r\n        }\r\n      }\r\n    });\r\n\r\n    if (invalid) {\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  onBeforeSaveList(){}\r\n  onAfterSaveList(){}\r\n  onAfterSaveListRequest(){}\r\n\r\n  // FT: Sending LastMenuIconIndexClicked class because of reference type\r\n  getCrudMenuForOrderedData = (\r\n    formArray: SpiderlyFormArray, \r\n    modelConstructor: BaseEntity, \r\n    lastMenuIconIndexClicked: LastMenuIconIndexClicked, \r\n    adjustFormArrayManually: boolean = false\r\n  ): MenuItem[] => {\r\n    let crudMenuForOrderedData: MenuItem[] = [\r\n        {label: this.translocoService.translate('Remove'), icon: 'pi pi-minus', command: () => {\r\n          this.onBeforeRemove(formArray, modelConstructor, lastMenuIconIndexClicked.index);\r\n          if (adjustFormArrayManually === false) {\r\n            this.removeFormControlFromTheFormArray(formArray, lastMenuIconIndexClicked.index);\r\n          }\r\n        }},\r\n        {label: this.translocoService.translate('AddAbove'), icon: 'pi pi-arrow-up', command: () => {\r\n          this.onBeforeAddAbove(formArray, modelConstructor, lastMenuIconIndexClicked.index);\r\n          if (adjustFormArrayManually === false) {\r\n            this.baseFormService.addNewFormGroupToFormArray(\r\n              formArray, modelConstructor, lastMenuIconIndexClicked.index\r\n            );\r\n          }\r\n        }},\r\n        {label: this.translocoService.translate('AddBelow'), icon: 'pi pi-arrow-down', command: () => {\r\n          this.onBeforeAddBelow(formArray, modelConstructor, lastMenuIconIndexClicked.index);\r\n          if (adjustFormArrayManually === false) {\r\n            this.baseFormService.addNewFormGroupToFormArray(\r\n              formArray, modelConstructor, lastMenuIconIndexClicked.index + 1\r\n            );\r\n          }\r\n        }},\r\n    ];\r\n\r\n    return crudMenuForOrderedData;\r\n  }\r\n\r\n  onBeforeRemove = (formArray: SpiderlyFormArray, modelConstructor: any, lastMenuIconIndexClicked: number) => {}\r\n\r\n  onBeforeAddAbove = (formArray: SpiderlyFormArray, modelConstructor: any, lastMenuIconIndexClicked: number) => {}\r\n\r\n  onBeforeAddBelow = (formArray: SpiderlyFormArray, modelConstructor: any, lastMenuIconIndexClicked: number) => {}\r\n\r\n  //#endregion\r\n\r\n}\r\n"]}

package/esm2022/lib/components/card-skeleton/card-skeleton.component.mjs

@@ -0,0 +1,25 @@
+import { Component, Input } from "@angular/core";
+import { SkeletonModule } from 'primeng/skeleton';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/skeleton";
+export class CardSkeletonComponent {
+    constructor() {
+        this.height = 400;
+        this.titleHeight = 23;
+        this.padding = 21;
+        this.titleMarginBottom = 14;
+        this.titleMarginTop = 4;
+    }
+    ngOnInit() {
+        this.dataHeight = this.height - (this.titleHeight + this.padding * 2 + this.titleMarginBottom + this.titleMarginTop);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CardSkeletonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CardSkeletonComponent, isStandalone: true, selector: "card-skeleton", inputs: { height: "height" }, ngImport: i0, template: "<div class=\"border-round border-1 surface-border p-4 surface-card\" [style]=\"'height: ' + height + 'px;'\">\r\n    <div [style]=\"'margin-bottom:' + titleMarginBottom + 'px; margin-top:' + titleMarginTop + 'px;'\">\r\n        <p-skeleton width=\"160px\" [height]=\"titleHeight + 'px'\"></p-skeleton>\r\n    </div>\r\n    <div [style]=\"'height: ' + dataHeight + 'px;'\">\r\n        <p-skeleton width=\"100%\" height=\"100%\"/>\r\n    </div>\r\n</div>", dependencies: [{ kind: "ngmodule", type: SkeletonModule }, { kind: "component", type: i1.Skeleton, selector: "p-skeleton", inputs: ["styleClass", "style", "shape", "animation", "borderRadius", "size", "width", "height"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CardSkeletonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'card-skeleton', standalone: true, imports: [SkeletonModule], template: "<div class=\"border-round border-1 surface-border p-4 surface-card\" [style]=\"'height: ' + height + 'px;'\">\r\n    <div [style]=\"'margin-bottom:' + titleMarginBottom + 'px; margin-top:' + titleMarginTop + 'px;'\">\r\n        <p-skeleton width=\"160px\" [height]=\"titleHeight + 'px'\"></p-skeleton>\r\n    </div>\r\n    <div [style]=\"'height: ' + dataHeight + 'px;'\">\r\n        <p-skeleton width=\"100%\" height=\"100%\"/>\r\n    </div>\r\n</div>" }]
+        }], propDecorators: { height: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/footer/footer.component.mjs

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/config-base.service";
+export class FooterComponent {
+    constructor(config) {
+        this.config = config;
+        this.companyName = this.config.companyName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FooterComponent, deps: [{ token: i1.ConfigBaseService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FooterComponent, isStandalone: true, selector: "footer", ngImport: i0, template: "<div class=\"layout-footer\">\r\n    <span class=\"font-medium ml-2\">{{companyName}}</span>\r\n</div>\r\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FooterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'footer', standalone: true, template: "<div class=\"layout-footer\">\r\n    <span class=\"font-medium ml-2\">{{companyName}}</span>\r\n</div>\r\n" }]
+        }], ctorParameters: () => [{ type: i1.ConfigBaseService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9vdGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NwaWRlcmx5L3NyYy9saWIvY29tcG9uZW50cy9mb290ZXIvZm9vdGVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NwaWRlcmx5L3NyYy9saWIvY29tcG9uZW50cy9mb290ZXIvZm9vdGVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQVExQyxNQUFNLE9BQU8sZUFBZTtJQUd4QixZQUNZLE1BQXlCO1FBQXpCLFdBQU0sR0FBTixNQUFNLENBQW1CO1FBSHJDLGdCQUFXLEdBQVcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUM7SUFNOUMsQ0FBQzsrR0FQUSxlQUFlO21HQUFmLGVBQWUsa0VDUjVCLDRHQUdBOzs0RkRLYSxlQUFlO2tCQUwzQixTQUFTOytCQUNJLFFBQVEsY0FFTixJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbmZpZ0Jhc2VTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvY29uZmlnLWJhc2Uuc2VydmljZSdcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gICAgc2VsZWN0b3I6ICdmb290ZXInLFxyXG4gICAgdGVtcGxhdGVVcmw6ICcuL2Zvb3Rlci5jb21wb25lbnQuaHRtbCcsXHJcbiAgICBzdGFuZGFsb25lOiB0cnVlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBGb290ZXJDb21wb25lbnQge1xyXG4gICAgY29tcGFueU5hbWU6IHN0cmluZyA9IHRoaXMuY29uZmlnLmNvbXBhbnlOYW1lO1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKFxyXG4gICAgICAgIHByaXZhdGUgY29uZmlnOiBDb25maWdCYXNlU2VydmljZVxyXG4gICAgKSB7IFxyXG5cclxuICAgIH1cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwibGF5b3V0LWZvb3RlclwiPlxyXG4gICAgPHNwYW4gY2xhc3M9XCJmb250LW1lZGl1bSBtbC0yXCI+e3tjb21wYW55TmFtZX19PC9zcGFuPlxyXG48L2Rpdj5cclxuIl19