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.1",
   "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

@@ -70,7 +70,6 @@ export class CreateCustomerComponent implements OnInit, OnDestroy {
       this.store.dispatch(new LoadProjectTypes(customerData.id));
       this.store.dispatch(new LoadCustomerProjects(customerData.id));
       this.changeValueAreTabsActives.emit(true);
-      this.hasChangedEvent.emit(this.hasChange = false);
       this.customerForm.setValue({
         name: customerData.name,
         description: customerData.description,
@@ -81,6 +80,7 @@ export class CreateCustomerComponent implements OnInit, OnDestroy {
       this.markTabsAsInactive();
       this.customerForm.reset();
     }
+    this.hasChangedEvent.emit((this.hasChange = false));
   }
 
   markTabsAsInactive() {

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

@@ -8,12 +8,13 @@ import {
   CustomerState,
   DeleteCustomer,
   LoadCustomers,
+  ResetCustomerToEdit,
   SetCustomerToEdit,
 } 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 +59,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 +86,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());
   });
@@ -102,6 +104,17 @@ describe('CustomerTableListComponent', () => {
     expect(store.dispatch).toHaveBeenCalledWith(new SetCustomerToEdit('1'));
   });
 
+  it('when you click close modal, if the idToEdit is equal currentCustomerIdToEdit should dispatch ResetCustomerToEdit', () => {
+
+    spyOn(store, 'dispatch');
+
+    component.idToEdit = '1';
+    component.currentCustomerIdToEdit = '1';
+    component.closeModal();
+
+    expect(store.dispatch).toHaveBeenCalledWith(new ResetCustomerToEdit());
+  });
+
   it('onClick delete, dispatch DeleteCustomer', () => {
     spyOn(store, 'dispatch');
     component.idToDelete = '1';
@@ -110,6 +123,17 @@ describe('CustomerTableListComponent', () => {
     expect(store.dispatch).toHaveBeenCalledWith(new DeleteCustomer('1'));
   });
 
+  it('onClick delete, if idToDelete is equal to currentCustomerIdToEdit should dispatch ResetCustomerToEdit', () => {
+
+    spyOn(store, 'dispatch');
+
+    component.idToDelete = '1';
+    component.currentCustomerIdToEdit = '1';
+    component.deleteCustomer();
+
+    expect(store.dispatch).toHaveBeenCalledWith(new ResetCustomerToEdit());
+  });
+
   const params = [
     { actionName: 'delete', actionType: CustomerManagementActionTypes.DELETE_CUSTOMER_SUCCESS },
     { actionName: 'update', actionType: CustomerManagementActionTypes.UPDATE_CUSTOMER_SUCCESS },