Merge branch 'master' into TT-20-Calculate-time-difference-when-new-entries-added

Author: wobravo

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "time-tracker",
-  "version": "1.35.0",
+  "version": "1.38.0",
   "scripts": {
     "preinstall": "npx npm-force-resolutions",
     "ng": "ng",
@@ -42,6 +42,7 @@
     "minimist": "^1.2.5",
     "moment": "^2.25.3",
     "msal": "^1.2.1",
+    "ngrx-store-localstorage": "^11.0.0",
     "ngx-cookie-service": "^11.0.2",
     "ngx-mask": "^9.1.2",
     "ngx-material-timepicker": "^5.5.3",
@@ -88,7 +89,7 @@
     "popper.js": "^1.16.0",
     "prettier": "^2.0.2",
     "protractor": "^7.0.0",
-    "semantic-release": "^17.3.0",
+    "semantic-release": "^17.4.2",
     "ts-node": "~8.3.0",
     "tslint": "~6.1.0",
     "typescript": "4.0.5"

package.json

@@ -1,4 +1,4 @@
-import { AdminGuard } from './guards/admin-guard/admin-guard';
+import { AdminGuard } from './guards/admin-guard/admin.guard';
 import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
 
@@ -26,7 +26,7 @@ const routes: Routes = [
       { path: 'activities-management', component: ActivitiesManagementComponent },
       { path: 'customers-management', canActivate: [AdminGuard], component: CustomerComponent },
       { path: 'users', canActivate: [AdminGuard], component: UsersComponent },
-      { path: 'technology-report', canActivate: [AdminGuard, TechnologiesReportGuard], component: TechnologyReportComponent},
+      { path: 'technology-report', canActivate: [AdminGuard, TechnologiesReportGuard], component: TechnologyReportComponent },
       { path: '', pathMatch: 'full', redirectTo: 'time-clock' },
     ],
   },
@@ -37,4 +37,4 @@ const routes: Routes = [
   imports: [RouterModule.forRoot(routes)],
   exports: [RouterModule],
 })
-export class AppRoutingModule {}
+export class AppRoutingModule { }

src/app/app-routing.module.ts

@@ -1,57 +1,129 @@
 import { inject, TestBed } from '@angular/core/testing';
 import { Router } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
-
+import { of } from 'rxjs';
+import { skip, take } from 'rxjs/operators';
+import { FeatureSwitchGroupService } from 'src/app/modules/shared/feature-toggles/switch-group/feature-switch-group.service';
+import { UserInfoService } from 'src/app/modules/user/services/user-info.service';
 import { AzureAdB2CService } from '../../modules/login/services/azure.ad.b2c.service';
-import { AdminGuard } from './admin-guard';
+import { AdminGuard } from './admin.guard';
 
 describe('AdminGuard', () => {
-
   let adminGuard: AdminGuard;
   let azureAdB2CService: AzureAdB2CService;
-
+  let userInfoService: UserInfoService;
+  let featureSwitchGroupService: FeatureSwitchGroupService;
   const azureAdB2CServiceStub = {
     isLogin() {
       return true;
     },
     isAdmin() {
       return true;
-    }
+    },
+  };
+
+  const userInfoServiceStub = {
+    isAdmin: () => of(false),
+  };
+
+  const featureSwitchGroupServiceStub = {
+    isActivated: () => of(false),
   };
 
   beforeEach(() => {
     TestBed.configureTestingModule({
       imports: [RouterTestingModule],
       providers: [
-        { providers: AzureAdB2CService, useValue: azureAdB2CServiceStub },
-      ]
+        { provide: AzureAdB2CService, useValue: azureAdB2CServiceStub },
+        { provide: UserInfoService, useValue: userInfoServiceStub },
+        { provide: FeatureSwitchGroupService, useValue: featureSwitchGroupServiceStub },
+      ],
     });
     adminGuard = TestBed.inject(AdminGuard);
     azureAdB2CService = TestBed.inject(AzureAdB2CService);
+    userInfoService = TestBed.inject(UserInfoService);
+    featureSwitchGroupService = TestBed.inject(FeatureSwitchGroupService);
   });
 
   it('should be created', () => {
     expect(adminGuard).toBeTruthy();
   });
 
-  it('can activate the route when user is logged-in', () => {
-    spyOn(azureAdB2CService, 'isAdmin').and.returnValue(true);
+  const roleParams = [{ bool: false }, { bool: true }];
+  roleParams.map((param) => {
+    it(`isAdminBasedInRole return ${param.bool}`, () => {
+      spyOn(azureAdB2CService, 'isAdmin').and.returnValue(param.bool);
+
+      adminGuard.isAdminBasedInRole().subscribe((enabled) => {
+        expect(azureAdB2CService.isAdmin).toHaveBeenCalled();
+        expect(enabled).toBe(param.bool);
+      });
+    });
+  });
+
+  const groupParams = [{ bool: false }, { bool: true }];
+  groupParams.map((param) => {
+    it(`isAdminBasedInGroup return ${param.bool}`, () => {
+      spyOn(userInfoService, 'isAdmin').and.returnValue(of(param.bool));
+
+      adminGuard.isAdminBasedInGroup().subscribe((enabled) => {
+        expect(userInfoService.isAdmin).toHaveBeenCalled();
+        expect(enabled).toBe(param.bool);
+      });
+    });
+  });
+
+  const switchToggleParams = [
+    { switchGroup: false, chosen: 'isAdminBasedInRole', isAdmin: true },
+    { switchGroup: true, chosen: 'isAdminBasedInGroup', isAdmin: false },
+  ];
+  switchToggleParams.map((param) => {
+    it(`on switchGroup ${param.switchGroup}, ${param.chosen} should be chosen`, () => {
+      const switchGroup$ = of(param.switchGroup);
+
+      spyOn(featureSwitchGroupService, 'isActivated').and.returnValue(switchGroup$);
+
+      const canActivate = adminGuard.canActivate();
 
-    const canActivate = adminGuard.canActivate();
+      featureSwitchGroupService.isActivated().pipe(take(1));
 
-    expect(azureAdB2CService.isAdmin).toHaveBeenCalled();
-    expect(canActivate).toEqual(true);
+      canActivate.subscribe((enabled) => {
+        expect(featureSwitchGroupService.isActivated).toHaveBeenCalled();
+        expect(enabled).toBe(param.isAdmin);
+      });
+    });
   });
 
-  it('can not active the route and is redirected to login if user is not logged-in', inject([Router], (router: Router) => {
-    spyOn(azureAdB2CService, 'isAdmin').and.returnValue(false);
-    spyOn(router, 'navigate').and.stub();
+  const navigateParams = [
+    { switchGroup: false, chosen: 'activate the route', isAdmin: true },
+    { switchGroup: false, chosen: 'redirect to /login', isAdmin: false },
+    { switchGroup: true, chosen: 'activate the route', isAdmin: true },
+    { switchGroup: true, chosen: 'redirect to /login', isAdmin: false },
+  ];
+  navigateParams.map((param) => {
+    it(`on isAdmin: ${param.isAdmin} with toggleSwitch: ${param.switchGroup}, should ${param.chosen} `, inject(
+      [Router],
+      (router: Router) => {
+        const switchGroup$ = of(param.switchGroup);
+        const isAdmin$ = of(param.isAdmin);
 
-    const canActivate = adminGuard.canActivate();
+        spyOn(featureSwitchGroupService, 'isActivated').and.returnValue(switchGroup$);
+        spyOn(adminGuard, 'isAdminBasedInRole').and.returnValue(isAdmin$);
+        spyOn(adminGuard, 'isAdminBasedInGroup').and.returnValue(isAdmin$);
+        spyOn(router, 'navigate').and.stub();
 
-    expect(azureAdB2CService.isAdmin).toHaveBeenCalled();
-    expect(canActivate).toEqual(false);
-    expect(router.navigate).toHaveBeenCalledWith(['login']);
-  }));
+        const canActivate = adminGuard.canActivate();
 
+        canActivate.subscribe((enabled) => {
+          expect(featureSwitchGroupService.isActivated).toHaveBeenCalled();
+          if (!enabled) {
+            expect(router.navigate).toHaveBeenCalledWith(['login']);
+          } else {
+            expect(router.navigate).not.toHaveBeenCalled();
+            expect(enabled).toBeTrue();
+          }
+        });
+      }
+    ));
+  });
 });

src/app/guards/admin-guard/admin-guard.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { Router, CanActivate } from '@angular/router';
+import { Observable, of } from 'rxjs';
+import { map, mergeMap } from 'rxjs/operators';
+import { FeatureSwitchGroupService } from 'src/app/modules/shared/feature-toggles/switch-group/feature-switch-group.service';
+import { UserInfoService } from 'src/app/modules/user/services/user-info.service';
+import { AzureAdB2CService } from '../../modules/login/services/azure.ad.b2c.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AdminGuard implements CanActivate {
+  constructor(
+    private azureAdB2CService: AzureAdB2CService,
+    private router: Router,
+    private userInfoService: UserInfoService,
+    private featureSwitchGroup: FeatureSwitchGroupService
+  ) {}
+
+  canActivate(): Observable<boolean> {
+    return this.featureSwitchGroup.isActivated().pipe(
+      mergeMap((enabled: boolean) => {
+        return enabled ? this.isAdminBasedInGroup() : this.isAdminBasedInRole();
+      }),
+      map((isAdmin: boolean): boolean => {
+        if (!isAdmin) {
+          this.router.navigate(['login']);
+        }
+        return isAdmin;
+      })
+    );
+  }
+
+  isAdminBasedInRole(): Observable<boolean> {
+    return of(this.azureAdB2CService.isAdmin());
+  }
+
+  isAdminBasedInGroup(): Observable<boolean> {
+    return this.userInfoService.isAdmin();
+  }
+}

src/app/guards/admin-guard/admin.guard.spec.ts

@@ -12,8 +12,8 @@ import {
 } from 'src/app/modules/customer-management/store';
 import { DataTablesModule } from 'angular-datatables';
 import { ActionsSubject } from '@ngrx/store';
-import { ResetProjectToEdit } from '../../../projects/components/store/project.actions';
-import { ResetProjectTypeToEdit } from '../../../projects-type/store';
+import { ResetProjectToEdit, SetProjectToEdit } from '../../../projects/components/store/project.actions';
+import { ResetProjectTypeToEdit, SetProjectTypeToEdit } from '../../../projects-type/store';
 
 describe('CustomerTableListComponent', () => {
   let component: CustomerListComponent;
@@ -58,7 +58,6 @@ describe('CustomerTableListComponent', () => {
     expect(store.dispatch).toHaveBeenCalledWith(new LoadCustomers());
   });
 
-
   it('Onclick Edit, if there are changes, the modal must be presented ', () => {
     component.hasChange = true;
     const expectMessage = 'Do you have changes in a client, do you want to discard them?';
@@ -86,6 +85,8 @@ describe('CustomerTableListComponent', () => {
 
     component.editCustomer('1');
 
+    expect(store.dispatch).toHaveBeenCalledWith(new SetProjectToEdit(null));
+    expect(store.dispatch).toHaveBeenCalledWith(new SetProjectTypeToEdit(null));
     expect(store.dispatch).toHaveBeenCalledWith(new ResetProjectToEdit());
     expect(store.dispatch).toHaveBeenCalledWith(new ResetProjectTypeToEdit());
   });

src/app/guards/admin-guard/admin.guard.ts

@@ -11,8 +11,9 @@ import {
   LoadCustomers,
   SetCustomerToEdit,
 } from './../../../../store/customer-management.actions';
-import { ResetProjectToEdit } from '../../../projects/components/store/project.actions';
-import { ResetProjectTypeToEdit } from '../../../projects-type/store';
+import { ResetProjectToEdit, SetProjectToEdit } from '../../../projects/components/store/project.actions';
+import { ResetProjectTypeToEdit, SetProjectTypeToEdit } from '../../../projects-type/store';
+
 @Component({
   selector: 'app-customer-list',
   templateUrl: './customer-list.component.html',
@@ -101,6 +102,8 @@ export class CustomerListComponent implements OnInit, OnDestroy, AfterViewInit {
   }
 
   private resetProjectFieldsToEdit() {
+    this.store.dispatch(new SetProjectTypeToEdit(null));
+    this.store.dispatch(new SetProjectToEdit(null));
     this.store.dispatch(new ResetProjectToEdit());
     this.store.dispatch(new ResetProjectTypeToEdit());
   }

src/app/modules/customer-management/components/customer-info/components/customer-list/customer-list.component.spec.ts

@@ -1,7 +1,7 @@
 import { waitForAsync, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormBuilder } from '@angular/forms';
 import { provideMockStore, MockStore } from '@ngrx/store/testing';
-
+import { ReactiveFormsModule } from '@angular/forms';
 import { CreateProjectTypeComponent } from './create-project-type.component';
 import {
   ProjectTypeState,
@@ -40,6 +40,7 @@ describe('InputProjectTypeComponent', () => {
 
   beforeEach(waitForAsync(() => {
     TestBed.configureTestingModule({
+      imports: [ReactiveFormsModule],
       declarations: [CreateProjectTypeComponent],
       providers: [FormBuilder, provideMockStore({ initialState: state })],
     }).compileComponents();
@@ -121,6 +122,15 @@ describe('InputProjectTypeComponent', () => {
     expect(store.dispatch).toHaveBeenCalledWith(new CreateProjectType(projectTypeData));
   });
 
+  it('should reset projectTypeForm if projectTypeIdToEdit is null', () => {
+
+    spyOn(component.projectTypeForm, 'reset');
+
+    store.overrideSelector(projectTypeIdToEdit, null);
+    store.refreshState();
+    expect(component.projectTypeForm.reset).toHaveBeenCalled();
+  });
+
   it('should get name using projectTypeForm', () => {
     spyOn(component.projectTypeForm, 'get');
     // tslint:disable-next-line:no-unused-expression

src/app/modules/customer-management/components/customer-info/components/customer-list/customer-list.component.ts

@@ -3,7 +3,7 @@ import { FormBuilder, Validators, FormGroup } from '@angular/forms';
 import { Store, select } from '@ngrx/store';
 
 import { ProjectType } from '../../../../../shared/models';
-import { ProjectTypeState } from '../../store';
+import { projectTypeIdToEdit, ProjectTypeState } from '../../store';
 import { CreateProjectType, ResetProjectTypeToEdit, UpdateProjectType, getProjectTypeById } from '../../store';
 import { getCustomerId } from 'src/app/modules/customer-management/store/customer-management.selectors';
 import { Subscription } from 'rxjs';
@@ -20,6 +20,7 @@ export class CreateProjectTypeComponent implements OnInit, OnDestroy {
   projectTypeToEdit: ProjectType;
   customerId: string;
   getCustomerIdSubscription: Subscription;
+  projectTypeIdToEditSubscription: Subscription;
 
   constructor(private formBuilder: FormBuilder, private store: Store<ProjectTypeState>) {
     this.projectTypeForm = this.formBuilder.group({
@@ -29,6 +30,13 @@ export class CreateProjectTypeComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit(): void {
+    const projectTypeIdToEdit$ = this.store.pipe(select(projectTypeIdToEdit));
+    this.projectTypeIdToEditSubscription = projectTypeIdToEdit$.subscribe((projectTypeId: string) => {
+      if (projectTypeId === null) {
+        this.projectTypeForm.reset();
+      }
+    });
+
     const projectType$ = this.store.pipe(select(getProjectTypeById));
     projectType$.subscribe((projectType) => {
       this.projectTypeToEdit = projectType;
@@ -79,6 +87,7 @@ export class CreateProjectTypeComponent implements OnInit, OnDestroy {
 
   ngOnDestroy(): void {
     this.getCustomerIdSubscription.unsubscribe();
+    this.projectTypeIdToEditSubscription.unsubscribe();
   }
 
   onInputChangeProjectType(searchValue: string): void {