Refactor user-related methods to include realm handling

- Updated user-related service methods to support realm IDs with default fallbacks.
- Adjusted API endpoint URLs and test cases to reflect added realm-specific logic.
- Minor formatting fixes and trailing comma additions for better consistency.

Author: tuplle

projects/netgrif-components-core/src/lib/authentication/models/user.transformer.spec.ts

@@ -10,15 +10,19 @@ describe('UserTransformer', () => {
         const userTransformer = new UserTransformer();
         expect(userTransformer.transform({
             id: 'string',
+            username: 'string',
+            realmId: 'string',
             email: 'string',
             name: 'string',
+            firstName: 'string',
             surname: 'string',
+            lastName: 'string',
             fullName: 'string string',
             groups: [],
             authorities: [{authority: 'ADMIN'}],
             processRoles: [{stringId: 'string', description: 'desc', name: 'name', importId: 'importId'}],
             nextGroups: [],
-            _links: {}
+            _links: {},
         }).fullName).toEqual('string string');
     });
 

projects/netgrif-components-core/src/lib/authorization/permission/permission.service.spec.ts

@@ -27,22 +27,22 @@ describe('PermissionService', () => {
                 NoopAnimationsModule,
                 BrowserAnimationsModule,
                 TranslateLibModule,
-                HttpClientTestingModule
+                HttpClientTestingModule,
             ],
             providers: [
                 PermissionService,
                 {provide: UserService, useClass: MockUserService},
             ],
             declarations: [],
-            schemas: [NO_ERRORS_SCHEMA]
+            schemas: [NO_ERRORS_SCHEMA],
         });
         permissionService = TestBed.inject(PermissionService);
         userService = TestBed.inject(UserService);
     }));
 
     it('should canAssign be true with role', () => {
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
         const task = {
             caseId: 'string',
             transitionId: 'string',
@@ -52,8 +52,8 @@ describe('PermissionService', () => {
             user: undefined,
             roles: {
                 assignRole: {
-                    assign: true
-                }
+                    assign: true,
+                },
             },
             startDate: undefined,
             finishDate: undefined,
@@ -64,19 +64,19 @@ describe('PermissionService', () => {
             layout: {
                 offset: 0,
                 cols: undefined,
-                rows: undefined
+                rows: undefined,
             },
             dataGroups: [],
             _links: {},
             users: {},
-            userRefs: {}
+            userRefs: {},
         };
         expect(permissionService.canAssign(task)).toBeTrue();
     });
 
     it('should canAssign be false with role', () => {
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
         const task = {
             caseId: 'string',
             transitionId: 'string',
@@ -86,8 +86,8 @@ describe('PermissionService', () => {
             user: undefined,
             roles: {
                 assignRole: {
-                    assign: false
-                }
+                    assign: false,
+                },
             },
             startDate: undefined,
             finishDate: undefined,
@@ -98,19 +98,19 @@ describe('PermissionService', () => {
             layout: {
                 offset: 0,
                 cols: undefined,
-                rows: undefined
+                rows: undefined,
             },
             dataGroups: [],
             _links: {},
             users: {},
-            userRefs: {}
+            userRefs: {},
         };
         expect(permissionService.canAssign(task)).toBeFalse();
     });
 
     it('should canAssign be true with userRef', () => {
         (userService as unknown as MockUserService).user =
-            new User('user123', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
+            new User('user123', '', '', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
         const task = {
             caseId: 'string',
             transitionId: 'string',
@@ -128,27 +128,27 @@ describe('PermissionService', () => {
             layout: {
                 offset: 0,
                 cols: undefined,
-                rows: undefined
+                rows: undefined,
             },
             dataGroups: [],
             _links: {},
             users: {
                 user123: {
-                    assign: true
-                }
+                    assign: true,
+                },
             },
             userRefs: {
                 userList1: {
-                    assign: true
-                }
-            }
+                    assign: true,
+                },
+            },
         };
         expect(permissionService.canAssign(task)).toBeTrue();
     });
 
     it('should canAssign be false with userRef', () => {
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'assignRole', name: '', importId: ''}]);
         const task = {
             caseId: 'string',
             transitionId: 'string',
@@ -166,31 +166,31 @@ describe('PermissionService', () => {
             layout: {
                 offset: 0,
                 cols: undefined,
-                rows: undefined
+                rows: undefined,
             },
             dataGroups: [],
             _links: {},
             users: {},
             userRefs: {
                 userList1: {
-                    assign: true
-                }
-            }
+                    assign: true,
+                },
+            },
         };
         expect(permissionService.canAssign(task)).toBeFalse();
     });
 
     it('should canDelete', () => {
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'deleteRole', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'deleteRole', name: '', importId: ''}]);
         const case_ = {
             stringId: 'string',
             title: 'string',
             author: {email: 'email', fullName: 'fullName'},
             permissions: {
                 deleteRole: {
-                    delete: true
-                }
+                    delete: true,
+                },
             },
             users: {},
             color: 'color',
@@ -207,29 +207,29 @@ describe('PermissionService', () => {
                 processIdentifier: 0,
                 time: 0,
                 timeSecond: 0,
-                timestamp: 0
+                timestamp: 0,
             },
             immediateData: [
                 {stringId: 'date', title: 'string', type: 'date', value: [2020, 1, 1, 10, 10]},
                 {stringId: 'string', title: 'string', type: 'string', value: 'dasdsadsad'},
                 {stringId: 'dateTime', title: 'string', type: 'dateTime', value: [2020, 1, 1, 10, 10]},
                 {stringId: 'enum', title: 'string', type: 'enumeration', value: {defaultValue: 'dasd'}},
-            ]
+            ],
         };
         expect(permissionService.hasCasePermission(case_, PermissionType.DELETE)).toBeTrue();
     });
 
     it('should canDelete be false', () => {
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'deleteRole', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'deleteRole', name: '', importId: ''}]);
         const case_ = {
             stringId: 'string',
             title: 'string',
             author: {email: 'email', fullName: 'fullName'},
             permissions: {
                 deleteRole: {
-                    delete: false
-                }
+                    delete: false,
+                },
             },
             users: {},
             color: 'color',
@@ -246,14 +246,14 @@ describe('PermissionService', () => {
                 processIdentifier: 0,
                 time: 0,
                 timeSecond: 0,
-                timestamp: 0
+                timestamp: 0,
             },
             immediateData: [
                 {stringId: 'date', title: 'string', type: 'date', value: [2020, 1, 1, 10, 10]},
                 {stringId: 'string', title: 'string', type: 'string', value: 'dasdsadsad'},
                 {stringId: 'dateTime', title: 'string', type: 'dateTime', value: [2020, 1, 1, 10, 10]},
                 {stringId: 'enum', title: 'string', type: 'enumeration', value: {defaultValue: 'dasd'}},
-            ]
+            ],
         };
         expect(permissionService.hasCasePermission(case_, PermissionType.DELEGATE)).toBeFalse();
     });
@@ -269,13 +269,13 @@ describe('PermissionService', () => {
             defaultCaseName: '',
             initials: '',
             version: '',
-            title: ''
+            title: '',
         });
         net.permissions = {};
         expect(permissionService.hasNetPermission(PermissionType.CREATE, net)).toBeFalse();
 
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [], [{stringId: 'role1', name: '', importId: ''}]);
+            new User('', '', '', '', '', '', [], [{stringId: 'role1', name: '', importId: ''}]);
         net.permissions = {role1: {create: true}};
         expect(permissionService.hasNetPermission(PermissionType.CREATE, net)).toBeTrue();
 
@@ -286,7 +286,7 @@ describe('PermissionService', () => {
         expect(permissionService.hasNetPermission(PermissionType.CREATE, net)).toBeFalse();
 
         (userService as unknown as MockUserService).user =
-            new User('', '', '', '', [],
+            new User('', '', '', '', '', '', [],
                 [{stringId: 'role1', name: '', importId: ''}, {stringId: 'role2', name: '', importId: ''}]);
         net.permissions = {role1: {create: false}, role2: {create: true}};
         expect(permissionService.hasNetPermission(PermissionType.CREATE, net)).toBeFalse();

projects/netgrif-components-core/src/lib/authorization/role/role-guard.service.spec.ts

@@ -1,21 +1,21 @@
 import {TestBed} from '@angular/core/testing';
 
-import {MaterialModule} from "../../material/material.module";
-import {CommonModule} from "@angular/common";
-import {FlexModule} from "@ngbracket/ngx-layout";
-import {BrowserAnimationsModule, NoopAnimationsModule} from "@angular/platform-browser/animations";
-import {TranslateLibModule} from "../../translate/translate-lib.module";
-import {HttpClientTestingModule} from "@angular/common/http/testing";
-import {UserService} from "../../user/services/user.service";
-import {MockUserService} from "../../utility/tests/mocks/mock-user.service";
-import { Injectable, NO_ERRORS_SCHEMA } from '@angular/core';
-import {ConfigurationService} from "../../configuration/configuration.service";
-import {TestConfigurationService} from "../../utility/tests/test-config";
-import {AuthenticationModule} from "../../authentication/authentication.module";
-import {RouterTestingModule} from "@angular/router/testing";
-import { RoleGuardService } from './role-guard.service';
-import { Access, View } from '../../../commons/schema';
-import { User } from '../../user/models/user';
+import {MaterialModule} from '../../material/material.module';
+import {CommonModule} from '@angular/common';
+import {FlexModule} from '@ngbracket/ngx-layout';
+import {BrowserAnimationsModule, NoopAnimationsModule} from '@angular/platform-browser/animations';
+import {TranslateLibModule} from '../../translate/translate-lib.module';
+import {HttpClientTestingModule} from '@angular/common/http/testing';
+import {UserService} from '../../user/services/user.service';
+import {MockUserService} from '../../utility/tests/mocks/mock-user.service';
+import {Injectable, NO_ERRORS_SCHEMA} from '@angular/core';
+import {ConfigurationService} from '../../configuration/configuration.service';
+import {TestConfigurationService} from '../../utility/tests/test-config';
+import {AuthenticationModule} from '../../authentication/authentication.module';
+import {RouterTestingModule} from '@angular/router/testing';
+import {RoleGuardService} from './role-guard.service';
+import {Access, View} from '../../../commons/schema';
+import {User} from '../../user/models/user';
 
 describe('RoleGuardService', () => {
     let service: RoleGuardService;
@@ -39,7 +39,7 @@ describe('RoleGuardService', () => {
                 {provide: UserService, useClass: CustomMockUserService},
             ],
             declarations: [],
-            schemas: [NO_ERRORS_SCHEMA]
+            schemas: [NO_ERRORS_SCHEMA],
         });
         service = TestBed.inject(RoleGuardService);
     });
@@ -49,22 +49,22 @@ describe('RoleGuardService', () => {
     });
 
     it('should access view with role only', () => {
-        const view = {access: {role: ['test.role_user']} as Access} as View
+        const view = {access: {role: ['test.role_user']} as Access} as View;
         expect(service.canAccessView(view, 'test')).toBeTrue();
     });
 
     it('should not access view', () => {
-        const view = {access: {role: [], bannedRole: []} as Access} as View
+        const view = {access: {role: [], bannedRole: []} as Access} as View;
         expect(service.canAccessView(view, 'test')).toBeFalse();
     });
 
     it('should not access view with banned role only', () => {
-        const view = {access: {bannedRole: ['test.banned_role']} as Access} as View
+        const view = {access: {bannedRole: ['test.banned_role']} as Access} as View;
         expect(service.canAccessView(view, 'test')).toBeFalse();
     });
 
     it('should not access view with role and banned role', () => {
-        const view = {access: {role: ['test.role_user'], bannedRole: ['test.banned_role']} as Access} as View
+        const view = {access: {role: ['test.role_user'], bannedRole: ['test.banned_role']} as Access} as View;
         expect(service.canAccessView(view, 'test')).toBeFalse();
     });
 });
@@ -73,22 +73,22 @@ describe('RoleGuardService', () => {
 class CustomMockUserService extends MockUserService {
     constructor() {
         super();
-        this._user = new User('123', 'test@netgrif.com', 'Test', 'User', ['ROLE_USER'], [{
+        this._user = new User('123', 'test@netgrif.com', 'test@netgrif.com', 'realm', 'Test', 'User', ['ROLE_USER'], [{
             stringId: 'role_user',
             name: 'role_user',
             description: '',
             importId: 'role_user',
             netImportId: 'test',
             netVersion: '1.0.0',
             netStringId: 'test',
-        },{
+        }, {
             stringId: 'banned_role',
             name: 'banned_role',
             description: '',
             importId: 'banned_role',
             netImportId: 'test',
             netVersion: '1.0.0',
             netStringId: 'test',
-        } ]);
+        }]);
     }
 }