add referrer to pageview events

src/app/core/services/browser.referrer.service.spec.ts

@@ -0,0 +1,53 @@
+import { of as observableOf } from 'rxjs';
+import { RouteService } from './route.service';
+import { BrowserReferrerService } from './browser.referrer.service';
+
+describe(`BrowserReferrerService`, () => {
+  let service: BrowserReferrerService;
+  const documentReferrer = 'https://www.referrer.com';
+  const origin = 'https://www.dspace.org';
+  let routeService: RouteService;
+
+  beforeEach(() => {
+    routeService = {
+      getPreviousUrl: () => observableOf('')
+    } as any;
+    service = new BrowserReferrerService(
+      { referrer: documentReferrer },
+      routeService,
+      { getCurrentOrigin: () => origin } as any
+    );
+  });
+
+  describe(`getReferrer`, () => {
+    let prevUrl: string;
+
+    describe(`when getPreviousUrl is an empty string`, () => {
+      beforeEach(() => {
+        prevUrl = '';
+        spyOn(routeService, 'getPreviousUrl').and.returnValue(observableOf(prevUrl));
+      });
+
+      it(`should return document.referrer`, (done: DoneFn) => {
+        service.getReferrer().subscribe((emittedReferrer: string) => {
+          expect(emittedReferrer).toBe(documentReferrer);
+          done();
+        });
+      });
+    });
+
+    describe(`when getPreviousUrl is not empty`, () => {
+      beforeEach(() => {
+        prevUrl = '/some/local/route';
+        spyOn(routeService, 'getPreviousUrl').and.returnValue(observableOf(prevUrl));
+      });
+
+      it(`should return the value emitted by getPreviousUrl combined with the origin from HardRedirectService`, (done: DoneFn) => {
+        service.getReferrer().subscribe((emittedReferrer: string) => {
+          expect(emittedReferrer).toBe(origin + prevUrl);
+          done();
+        });
+      });
+    });
+  });
+});

src/app/core/services/browser.referrer.service.ts

@@ -0,0 +1,48 @@
+import { ReferrerService } from './referrer.service';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { isEmpty } from '../../shared/empty.util';
+import { URLCombiner } from '../url-combiner/url-combiner';
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { HardRedirectService } from './hard-redirect.service';
+import { RouteService } from './route.service';
+
+/**
+ * A service to determine the referrer
+ *
+ * The browser implementation will get the referrer from document.referrer, in the event that the
+ * previous page visited was not an angular URL. If it was, the route history in the store must be
+ * used, since document.referrer doesn't get updated on route changes
+ */
+@Injectable()
+export class BrowserReferrerService extends ReferrerService {
+
+  constructor(
+    @Inject(DOCUMENT) protected document: any,
+    protected routeService: RouteService,
+    protected hardRedirectService: HardRedirectService,
+  ) {
+    super();
+  }
+
+  /**
+   * Return the referrer
+   *
+   * Return the referrer URL based on the route history in the store. If there is no route history
+   * in the store yet, document.referrer will be used
+   */
+  public getReferrer(): Observable<string> {
+    return this.routeService.getPreviousUrl().pipe(
+      map((prevUrl: string) => {
+        // if we don't have anything in the history yet, return document.referrer
+        // (note that that may be empty too, e.g. if you've just opened a new browser tab)
+        if (isEmpty(prevUrl)) {
+          return this.document.referrer;
+        } else {
+          return new URLCombiner(this.hardRedirectService.getCurrentOrigin(), prevUrl).toString();
+        }
+      })
+    );
+  }
+}

src/app/core/services/referrer.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * A service to determine the referrer, i.e. the previous URL that led the user to the current one
+ */
+@Injectable()
+export abstract class ReferrerService {
+
+  /**
+   * Return the referrer
+   */
+  abstract getReferrer(): Observable<string>;
+
+}

src/app/core/services/server.referrer.service.spec.ts

@@ -0,0 +1,34 @@
+import { ServerReferrerService } from './server.referrer.service';
+
+describe(`ServerReferrerService`, () => {
+  let service: ServerReferrerService;
+  const referrer = 'https://www.referrer.com';
+
+  describe(`getReferrer`, () => {
+    describe(`when the referer header is set`, () => {
+      beforeEach(() => {
+        service = new ServerReferrerService({ headers: { referer: referrer }});
+      });
+
+      it(`should return the referer header`, (done: DoneFn) => {
+        service.getReferrer().subscribe((emittedReferrer: string) => {
+          expect(emittedReferrer).toBe(referrer);
+          done();
+        });
+      });
+    });
+
+    describe(`when the referer header is not set`, () => {
+      beforeEach(() => {
+        service = new ServerReferrerService({ headers: {}});
+      });
+
+      it(`should return an empty string`, (done: DoneFn) => {
+        service.getReferrer().subscribe((emittedReferrer: string) => {
+          expect(emittedReferrer).toBe('');
+          done();
+        });
+      });
+    });
+  });
+});

src/app/core/services/server.referrer.service.ts

@@ -0,0 +1,31 @@
+import { ReferrerService } from './referrer.service';
+import { Observable, of as observableOf } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { REQUEST } from '@nguniversal/express-engine/tokens';
+
+/**
+ * A service to determine the referrer
+ *
+ * The server implementation will get the referrer from the 'Referer' header of the request sent to
+ * the express server
+ */
+@Injectable()
+export class ServerReferrerService extends ReferrerService {
+
+  constructor(
+    @Inject(REQUEST) protected request: any,
+  ) {
+    super();
+  }
+
+  /**
+   * Return the referrer
+   *
+   * Return the 'Referer' header from the request, or an empty string if the header wasn't set
+   * (for consistency with the document.referrer property on the browser side)
+   */
+  public getReferrer(): Observable<string> {
+    const referrer = this.request.headers.referer || '';
+    return observableOf(referrer);
+  }
+}

src/app/statistics/angulartics/dspace-provider.spec.ts

@@ -11,7 +11,10 @@ describe('Angulartics2DSpace', () => {
 
   beforeEach(() => {
     angulartics2 = {
-      eventTrack: observableOf({action: 'page_view', properties: {object: 'mock-object'}}),
+      eventTrack: observableOf({action: 'page_view', properties: {
+        object: 'mock-object',
+        referrer: 'https://www.referrer.com'
+      }}),
       filterDeveloperMode: () => filter(() => true)
     } as any;
     statisticsService = jasmine.createSpyObj('statisticsService', {trackViewEvent: null});
@@ -20,7 +23,7 @@ describe('Angulartics2DSpace', () => {
 
   it('should use the statisticsService', () => {
     provider.startTracking();
-    expect(statisticsService.trackViewEvent).toHaveBeenCalledWith('mock-object' as any);
+    expect(statisticsService.trackViewEvent).toHaveBeenCalledWith('mock-object' as any, 'https://www.referrer.com');
   });
 
 });

src/app/statistics/angulartics/dspace-provider.ts

@@ -25,7 +25,7 @@ export class Angulartics2DSpace {
 
   private eventTrack(event) {
     if (event.action === 'page_view') {
-      this.statisticsService.trackViewEvent(event.properties.object);
+      this.statisticsService.trackViewEvent(event.properties.object, event.properties.referrer);
     } else if (event.action === 'search') {
       this.statisticsService.trackSearchEvent(
         event.properties.searchOptions,

src/app/statistics/angulartics/dspace/view-tracker.component.ts

@@ -1,6 +1,10 @@
-import { Component, Input, OnInit } from '@angular/core';
+import { Component, Input, OnInit, OnDestroy } from '@angular/core';
 import { Angulartics2 } from 'angulartics2';
 import { DSpaceObject } from '../../../core/shared/dspace-object.model';
+import { Subscription } from 'rxjs/internal/Subscription';
+import { take } from 'rxjs/operators';
+import { hasValue } from '../../../shared/empty.util';
+import { ReferrerService } from '../../../core/services/referrer.service';
 
 /**
  * This component triggers a page view statistic
@@ -10,18 +14,43 @@ import { DSpaceObject } from '../../../core/shared/dspace-object.model';
   styleUrls: ['./view-tracker.component.scss'],
   templateUrl: './view-tracker.component.html',
 })
-export class ViewTrackerComponent implements OnInit {
+export class ViewTrackerComponent implements OnInit, OnDestroy {
+  /**
+   * The DSpaceObject to track a view event about
+   */
   @Input() object: DSpaceObject;
 
+  /**
+   * The subscription on this.referrerService.getReferrer()
+   * @protected
+   */
+  protected sub: Subscription;
+
   constructor(
-    public angulartics2: Angulartics2
+    public angulartics2: Angulartics2,
+    public referrerService: ReferrerService
   ) {
   }
 
   ngOnInit(): void {
-    this.angulartics2.eventTrack.next({
+    this.sub = this.referrerService.getReferrer()
-      action: 'page_view',
+      .pipe(take(1))
-      properties: {object: this.object},
+      .subscribe((referrer: string) => {
-    });
+        this.angulartics2.eventTrack.next({
+          action: 'page_view',
+          properties: {
+            object: this.object,
+            referrer
+          },
+        });
+      });
+  }
+
+  ngOnDestroy(): void {
+    // unsubscribe in the case that this component is destroyed before
+    // this.referrerService.getReferrer() has emitted
+    if (hasValue(this.sub)) {
+      this.sub.unsubscribe();
+    }
   }
 }

src/app/statistics/statistics.service.spec.ts

@@ -26,12 +26,13 @@ describe('StatisticsService', () => {
 
     it('should send a request to track an item view ', () => {
       const mockItem: any = {uuid: 'mock-item-uuid', type: 'item'};
-      service.trackViewEvent(mockItem);
+      service.trackViewEvent(mockItem, 'https://www.referrer.com');
       const request: RestRequest = requestService.send.calls.mostRecent().args[0];
       expect(request.body).toBeDefined('request.body');
       const body = JSON.parse(request.body);
       expect(body.targetId).toBe('mock-item-uuid');
       expect(body.targetType).toBe('item');
+      expect(body.referrer).toBe('https://www.referrer.com');
     });
   });
 

src/app/statistics/statistics.service.ts

@@ -31,11 +31,16 @@ export class StatisticsService {
   /**
    * To track a page view
    * @param dso: The dso which was viewed
+   * @param referrer: The referrer used by the client to reach the dso page
    */
-  trackViewEvent(dso: DSpaceObject) {
+  trackViewEvent(
+    dso: DSpaceObject,
+    referrer: string
+  ) {
     this.sendEvent('/statistics/viewevents', {
       targetId: dso.uuid,
-      targetType: (dso as any).type
+      targetType: (dso as any).type,
+      referrer
     });
   }
 

src/modules/app/browser-app.module.ts

@@ -32,6 +32,8 @@ import { AuthRequestService } from '../../app/core/auth/auth-request.service';
 import { BrowserAuthRequestService } from '../../app/core/auth/browser-auth-request.service';
 import { BrowserInitService } from './browser-init.service';
 import { VocabularyTreeviewService } from 'src/app/shared/form/vocabulary-treeview/vocabulary-treeview.service';
+import { ReferrerService } from '../../app/core/services/referrer.service';
+import { BrowserReferrerService } from '../../app/core/services/browser.referrer.service';
 
 export const REQ_KEY = makeStateKey<string>('req');
 
@@ -108,6 +110,10 @@ export function getRequest(transferState: TransferState): any {
       provide: AuthRequestService,
       useClass: BrowserAuthRequestService,
     },
+    {
+      provide: ReferrerService,
+      useClass: BrowserReferrerService,
+    },
     {
       provide: LocationToken,
       useFactory: locationProvider,

src/modules/app/server-app.module.ts

@@ -35,6 +35,8 @@ import { ServerAuthRequestService } from '../../app/core/auth/server-auth-reques
 import { ServerInitService } from './server-init.service';
 import { XhrFactory } from '@angular/common';
 import { ServerXhrService } from '../../app/core/services/server-xhr.service';
+import { ReferrerService } from '../../app/core/services/referrer.service';
+import { ServerReferrerService } from '../../app/core/services/server.referrer.service';
 
 export function createTranslateLoader(transferState: TransferState) {
   return new TranslateServerLoader(transferState, 'dist/server/assets/i18n/', '.json');
@@ -110,6 +112,10 @@ export function createTranslateLoader(transferState: TransferState) {
       provide: XhrFactory,
       useClass: ServerXhrService,
     },
+    {
+      provide: ReferrerService,
+      useClass: ServerReferrerService,
+    },
   ]
 })
 export class ServerAppModule {