build: Add build process for newgui (#7351)

next-gen-gui/src/app/http-interceptors/caching.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CachingInterceptor } from './caching.interceptor';
+
+describe('CachingInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      CachingInterceptor
+      ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: CachingInterceptor = TestBed.inject(CachingInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

next-gen-gui/src/app/http-interceptors/caching.interceptor.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+  HttpHeaders,
+  HttpResponse
+} from '@angular/common/http';
+import { Observable, of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { RequestCacheService } from '../services/request-cache.service'
+
+@Injectable()
+export class CachingInterceptor implements HttpInterceptor {
+  constructor(private cache: RequestCacheService) { }
+
+  intercept(req: HttpRequest<any>, next: HttpHandler) {
+    // continue if not cachable.
+    if (!isCachable(req)) { return next.handle(req); }
+
+    const cachedResponse = this.cache.get(req);
+    return cachedResponse ?
+      of(cachedResponse) : sendRequest(req, next, this.cache);
+  }
+}
+
+/** Is this request cachable? */
+function isCachable(req: HttpRequest<any>) {
+  // Only GET requests are cachable
+  return req.method === 'GET';
+  /*
+  return req.method === 'GET' &&
+    -1 < req.url.indexOf("url");
+    */
+}
+
+/**
+ * Get server response observable by sending request to `next()`.
+ * Will add the response to the cache on the way out.
+ */
+function sendRequest(
+  req: HttpRequest<any>,
+  next: HttpHandler,
+  cache: RequestCacheService): Observable<HttpEvent<any>> {
+
+  // No headers allowed in npm search request
+  const noHeaderReq = req.clone({ headers: new HttpHeaders() });
+
+  return next.handle(noHeaderReq).pipe(
+    tap(event => {
+      // There may be other events besides the response.
+      if (event instanceof HttpResponse) {
+        // cache.put(req, event); // Update the cache.
+      }
+    })
+  );
+}

next-gen-gui/src/app/http-interceptors/csrf.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CSRFInterceptor } from './csrf.interceptor';
+
+describe('CsrfInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      CSRFInterceptor
+    ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: CSRFInterceptor = TestBed.inject(CSRFInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

next-gen-gui/src/app/http-interceptors/csrf.interceptor.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { deviceID } from '../api-utils';
+import {
+  HttpInterceptor, HttpHandler, HttpRequest, HttpHeaders
+} from '@angular/common/http';
+
+import { CookieService } from '../services/cookie.service';
+
+
+@Injectable()
+export class CSRFInterceptor implements HttpInterceptor {
+
+  constructor(private cookieService: CookieService) { }
+
+  intercept(req: HttpRequest<any>, next: HttpHandler) {
+    const dID: String = deviceID();
+    const csrfCookie = 'CSRF-Token-' + dID
+
+    // Clone the request and replace the original headers with
+    // cloned headers, updated with the CSRF information.
+    const csrfReq = req.clone({
+      headers: req.headers.set('X-CSRF-Token-' + dID,
+        this.cookieService.getCookie(csrfCookie))
+    });
+
+    // send cloned request with header to the next handler.
+    return next.handle(csrfReq);
+  }
+}

next-gen-gui/src/app/http-interceptors/error.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ErrorInterceptor } from './error.interceptor';
+
+describe('ErrorInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      ErrorInterceptor
+      ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: ErrorInterceptor = TestBed.inject(ErrorInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

next-gen-gui/src/app/http-interceptors/error.interceptor.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+  HttpErrorResponse
+} from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { apiRetry } from '../api-utils';
+import { retry, catchError } from 'rxjs/operators';
+import { MessageService } from '../services/message.service';
+
+@Injectable()
+export class ErrorInterceptor implements HttpInterceptor {
+
+  constructor(private messageService: MessageService) { }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(request)
+      .pipe(
+        retry(apiRetry),
+        catchError((error: HttpErrorResponse) => {
+          let errorMsg: string;
+          if (error.error instanceof ErrorEvent) {
+            // Client side
+            errorMsg = `Error: ${error.error.message}`;
+          } else {
+            // Server side
+            errorMsg = `Error Status: ${error.status}\nMessage: ${error.message}`;
+          }
+          console.log(errorMsg);
+
+          this.messageService.add(errorMsg);
+          return throwError(errorMsg);
+        })
+      )
+  }
+}

next-gen-gui/src/app/http-interceptors/index.ts

@@ -0,0 +1,14 @@
+/* "Barrel" of Http Interceptors */
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+
+import { CSRFInterceptor } from './csrf.interceptor';
+import { CachingInterceptor } from './caching.interceptor';
+import { ErrorInterceptor } from './error.interceptor';
+
+/** Http interceptor providers in outside-in order */
+export const httpInterceptorProviders = [
+    { provide: HTTP_INTERCEPTORS, useClass: CachingInterceptor, multi: true },
+    { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true },
+    // CSRFInterceptor needs to be last 
+    { provide: HTTP_INTERCEPTORS, useClass: CSRFInterceptor, multi: true },
+];