Merge pull request DSpace#1816 from 4Science/CST-6565

Cookie consent shows analytics usage also when GA is disabled

Author: tdonohue

src/app/shared/cookies/browser-klaro.service.spec.ts

@@ -10,21 +10,36 @@ import { AuthService } from '../../core/auth/auth.service';
 import { CookieService } from '../../core/services/cookie.service';
 import { getTestScheduler } from 'jasmine-marbles';
 import { MetadataValue } from '../../core/shared/metadata.models';
-import { cloneDeep } from 'lodash';
+import {clone, cloneDeep} from 'lodash';
+import { ConfigurationDataService } from '../../core/data/configuration-data.service';
+import {createFailedRemoteDataObject$, createSuccessfulRemoteDataObject$} from '../remote-data.utils';
+import { ConfigurationProperty } from '../../core/shared/configuration-property.model';
 
 describe('BrowserKlaroService', () => {
+  const trackingIdProp = 'google.analytics.key';
+  const trackingIdTestValue = 'mock-tracking-id';
+  const googleAnalytics = 'google-analytics';
   let translateService;
   let ePersonService;
   let authService;
   let cookieService;
 
   let user;
   let service: BrowserKlaroService;
+  let configurationDataService: ConfigurationDataService;
+  const createConfigSuccessSpy = (...values: string[]) => jasmine.createSpyObj('configurationDataService', {
+    findByPropertyName: createSuccessfulRemoteDataObject$({
+      ... new ConfigurationProperty(),
+      name: trackingIdProp,
+      values: values,
+    }),
+  });
 
   let mockConfig;
   let appName;
   let purpose;
   let testKey;
+  let findByPropertyName;
 
   beforeEach(() => {
     user = new EPerson();
@@ -38,6 +53,8 @@ describe('BrowserKlaroService', () => {
       isAuthenticated: observableOf(true),
       getAuthenticatedUserFromStore: observableOf(user)
     });
+    configurationDataService = createConfigSuccessSpy(trackingIdTestValue);
+    findByPropertyName = configurationDataService.findByPropertyName;
     cookieService = jasmine.createSpyObj('cookieService', {
       get: '{%22token_item%22:true%2C%22impersonation%22:true%2C%22redirect%22:true%2C%22language%22:true%2C%22klaro%22:true%2C%22has_agreed_end_user%22:true%2C%22google-analytics%22:true}',
       set: () => {
@@ -63,6 +80,10 @@ describe('BrowserKlaroService', () => {
         {
           provide: CookieService,
           useValue: cookieService
+        },
+        {
+          provide: ConfigurationDataService,
+          useValue: configurationDataService
         }
       ]
     });
@@ -83,6 +104,9 @@ describe('BrowserKlaroService', () => {
       services: [{
         name: appName,
         purposes: [purpose]
+      },{
+        name: googleAnalytics,
+        purposes: [purpose]
       }],
 
     };
@@ -233,4 +257,54 @@ describe('BrowserKlaroService', () => {
       expect(ePersonService.patch).not.toHaveBeenCalled();
     });
   });
+
+  describe('initialize google analytics configuration', () => {
+    let GOOGLE_ANALYTICS_KEY;
+    beforeEach(() => {
+      GOOGLE_ANALYTICS_KEY = clone((service as any).GOOGLE_ANALYTICS_KEY);
+      configurationDataService.findByPropertyName = findByPropertyName;
+      spyOn((service as any), 'getUser$').and.returnValue(observableOf(user));
+      translateService.get.and.returnValue(observableOf('loading...'));
+      spyOn(service, 'addAppMessages');
+      spyOn((service as any), 'initializeUser');
+      spyOn(service, 'translateConfiguration');
+    });
+    it('should not filter googleAnalytics when servicesToHide are empty', () => {
+      const filteredConfig = (service as any).filterConfigServices([]);
+      expect(filteredConfig).toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+    it('should filter services using names passed as servicesToHide', () => {
+      const filteredConfig = (service as any).filterConfigServices([googleAnalytics]);
+      expect(filteredConfig).not.toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+    it('should have been initialized with googleAnalytics', () => {
+      service.initialize();
+      expect(service.klaroConfig.services).toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+    it('should filter googleAnalytics when empty configuration is retrieved', () => {
+      configurationDataService.findByPropertyName = jasmine.createSpy().withArgs(GOOGLE_ANALYTICS_KEY).and.returnValue(
+        createSuccessfulRemoteDataObject$({
+          ... new ConfigurationProperty(),
+          name: googleAnalytics,
+          values: [],
+        }));
+
+      service.initialize();
+      expect(service.klaroConfig.services).not.toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+    it('should filter googleAnalytics when an error occurs', () => {
+      configurationDataService.findByPropertyName = jasmine.createSpy().withArgs(GOOGLE_ANALYTICS_KEY).and.returnValue(
+        createFailedRemoteDataObject$('Erro while loading GA')
+      );
+      service.initialize();
+      expect(service.klaroConfig.services).not.toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+    it('should filter googleAnalytics when an invalid payload is retrieved', () => {
+      configurationDataService.findByPropertyName = jasmine.createSpy().withArgs(GOOGLE_ANALYTICS_KEY).and.returnValue(
+        createSuccessfulRemoteDataObject$(null)
+      );
+      service.initialize();
+      expect(service.klaroConfig.services).not.toContain(jasmine.objectContaining({name: googleAnalytics}));
+    });
+  });
 });

src/app/shared/cookies/browser-klaro.service.ts

@@ -4,15 +4,17 @@ import { combineLatest as observableCombineLatest, Observable, of as observableO
 import { AuthService } from '../../core/auth/auth.service';
 import { TranslateService } from '@ngx-translate/core';
 import { environment } from '../../../environments/environment';
-import { switchMap, take } from 'rxjs/operators';
+import { map, switchMap, take } from 'rxjs/operators';
 import { EPerson } from '../../core/eperson/models/eperson.model';
 import { KlaroService } from './klaro.service';
-import { hasValue, isNotEmpty } from '../empty.util';
+import { hasValue, isEmpty, isNotEmpty } from '../empty.util';
 import { CookieService } from '../../core/services/cookie.service';
 import { EPersonDataService } from '../../core/eperson/eperson-data.service';
 import { cloneDeep, debounce } from 'lodash';
 import { ANONYMOUS_STORAGE_NAME_KLARO, klaroConfiguration } from './klaro-configuration';
 import { Operation } from 'fast-json-patch';
+import { getFirstCompletedRemoteData} from '../../core/shared/operators';
+import { ConfigurationDataService } from '../../core/data/configuration-data.service';
 
 /**
  * Metadata field to store a user's cookie consent preferences in
@@ -38,23 +40,31 @@ const cookiePurposeMessagePrefix = 'cookies.consent.purpose.';
  * Update request debounce in ms
  */
 const updateDebounce = 300;
+
 /**
  * Browser implementation for the KlaroService, representing a service for handling Klaro consent preferences and UI
  */
 @Injectable()
 export class BrowserKlaroService extends KlaroService {
+
+  private readonly GOOGLE_ANALYTICS_KEY = 'google.analytics.key';
+
+  private readonly GOOGLE_ANALYTICS_SERVICE_NAME = 'google-analytics';
+
   /**
    * Initial Klaro configuration
    */
-  klaroConfig = klaroConfiguration;
+  klaroConfig = cloneDeep(klaroConfiguration);
 
   constructor(
     private translateService: TranslateService,
     private authService: AuthService,
     private ePersonService: EPersonDataService,
+    private configService: ConfigurationDataService,
     private cookieService: CookieService) {
     super();
   }
+
   /**
    * Initializes the service:
    *  - Retrieves the current authenticated user
@@ -68,14 +78,25 @@ export class BrowserKlaroService extends KlaroService {
       this.klaroConfig.translations.en.consentNotice.description = 'cookies.consent.content-notice.description.no-privacy';
     }
 
+    const servicesToHide$: Observable<string[]> = this.configService.findByPropertyName(this.GOOGLE_ANALYTICS_KEY).pipe(
+      getFirstCompletedRemoteData(),
+      map(remoteData => {
+        if (!remoteData.hasSucceeded || !remoteData.payload || isEmpty(remoteData.payload.values)) {
+          return [this.GOOGLE_ANALYTICS_SERVICE_NAME];
+        } else {
+          return [];
+        }
+      }),
+    );
+
     this.translateService.setDefaultLang(environment.defaultLanguage);
 
     const user$: Observable<EPerson> = this.getUser$();
 
     const translationServiceReady$ = this.translateService.get('loading.default').pipe(take(1));
 
-    observableCombineLatest([user$, translationServiceReady$])
-      .subscribe(([user, translation]: [EPerson, string]) => {
+    observableCombineLatest([user$, servicesToHide$, translationServiceReady$])
+      .subscribe(([user, servicesToHide, _]: [EPerson, string[], string]) => {
         user = cloneDeep(user);
 
         if (hasValue(user)) {
@@ -93,6 +114,9 @@ export class BrowserKlaroService extends KlaroService {
          * Show the configuration if the configuration has not been confirmed
          */
         this.translateConfiguration();
+
+        this.klaroConfig.services = this.filterConfigServices(servicesToHide);
+
         Klaro.setup(this.klaroConfig);
       });
   }
@@ -168,7 +192,10 @@ export class BrowserKlaroService extends KlaroService {
    */
   addAppMessages() {
     this.klaroConfig.services.forEach((app) => {
-      this.klaroConfig.translations.en[app.name] = { title: this.getTitleTranslation(app.name), description: this.getDescriptionTranslation(app.name) };
+      this.klaroConfig.translations.en[app.name] = {
+        title: this.getTitleTranslation(app.name),
+        description: this.getDescriptionTranslation(app.name)
+      };
       app.purposes.forEach((purpose) => {
         this.klaroConfig.translations.en.purposes[purpose] = this.getPurposeTranslation(purpose);
       });
@@ -257,4 +284,11 @@ export class BrowserKlaroService extends KlaroService {
   getStorageName(identifier: string) {
     return 'klaro-' + identifier;
   }
+
+  /**
+   * remove the google analytics from the services
+   */
+  private filterConfigServices(servicesToHide: string[]): Pick<typeof klaroConfiguration, 'services'>[] {
+    return this.klaroConfig.services.filter(service => !servicesToHide.some(name => name === service.name));
+  }
 }