Backlog/v11 federation

frontend/src/app/app-routing.module.ts

@@ -1,6 +1,12 @@
 import {NgModule} from '@angular/core';
 import {RouterModule, Routes} from '@angular/router';
 import {UserRouteAccessService} from './core/auth/user-route-access-service';
+import {FederationDisabledGuard} from './federation/guards/federation-disabled.guard';
+import {
+  FederationEmailConfigPageComponent
+} from './federation/pages/email-config/federation-email-config.page.component';
+import {TeamMembersPageComponent} from './federation/pages/team-members/team-members.page.component';
+import {WelcomeComponent as FederationWelcomeComponent} from './federation/pages/welcome/welcome.component';
 import {ConfirmIdentityComponent} from './shared/components/auth/confirm-identity/confirm-identity.component';
 import {LoginComponent} from './shared/components/auth/login/login.component';
 import {
@@ -69,7 +75,8 @@ const routes: Routes = [
   {
     path: 'app-management',
     loadChildren: './app-management/app-management.module#AppManagementModule',
-    canActivate: [UserRouteAccessService],
+    canActivate: [UserRouteAccessService, FederationDisabledGuard],
+    canActivateChild: [FederationDisabledGuard],
     data: {authorities: [USER_ROLE, ADMIN_ROLE]}
   },
   {
@@ -152,9 +159,26 @@ const routes: Routes = [
     canActivate: [UserRouteAccessService],
     data: {authorities: [ADMIN_ROLE, USER_ROLE]}
   },
+  {
+    path: 'federation',
+    canActivate: [UserRouteAccessService],
+    data: {authorities: [ADMIN_ROLE, USER_ROLE]},
+    children: [
+      {path: '', redirectTo: 'welcome', pathMatch: 'full'},
+      {path: 'welcome', component: FederationWelcomeComponent},
+      {path: 'instances', component: FederationWelcomeComponent},
+      {path: 'team-members', component: TeamMembersPageComponent},
+      {
+        path: 'email-config',
+        component: FederationEmailConfigPageComponent,
+        data: {authorities: [ADMIN_ROLE]}
+      }
+    ]
+  },
   {path: '', component: LoginComponent},
   {path: 'totp', component: TotpComponent},
   {path: 'enroll-tfa', component: TfaSetupComponent},
+  {path: 'auth/login', component: PasswordResetFinishComponent},
   {path: 'reset/finish', component: PasswordResetFinishComponent},
   {path: 'page-not-found', component: NotFoundComponent},
   {path: 'confirm-identity/:id', component: ConfirmIdentityComponent},

frontend/src/app/app.component.html

@@ -1,16 +1,19 @@
 <div class="app-container">
   <app-header *appHasAnyAuthority="roles" [hidden]="isInExportRoute()"></app-header>
-  <div [class]="isInExportRoute() ? ' wrapper wrapper-no-top' : 'wrapper'" [ngClass]="menu ? 'menu-open': 'menu-close'">
+  <div [class]="isInExportRoute() ? ' wrapper wrapper-no-top' : 'wrapper'"
+       [ngClass]="(federationActive$ | async) ? 'federation-mode' : (menu ? 'menu-open': 'menu-close')">
     <div class="main-content">
       <router-outlet></router-outlet>
     </div>
 
-    <div *appHasAnyAuthority="roles" [hidden]="!menu || isInExportRoute()" class="side-menu">
-      <div
-        class="sidebar sidebar-light sidebar-main sidebar-expand-md">
-        <app-sidebar></app-sidebar>
+    <ng-container *appHasAnyAuthority="roles">
+      <div *ngIf="!(federationActive$ | async)"
+           [hidden]="!menu || isInExportRoute()" class="side-menu">
+        <div class="sidebar sidebar-light sidebar-main sidebar-expand-md">
+          <app-sidebar></app-sidebar>
+        </div>
       </div>
-    </div>
+    </ng-container>
   </div>
   <!--<app-app-restart-api></app-app-restart-api>-->
   <ngx-spinner

frontend/src/app/app.component.scss

@@ -94,6 +94,10 @@
   animation: ease-in;
 }
 
+.federation-mode {
+  margin-left: 0;
+}
+
 //
 //app-mobile-header {
 //  display: none;

frontend/src/app/app.component.ts

@@ -1,17 +1,19 @@
 import {Component, HostListener, OnInit, Renderer2} from '@angular/core';
 import {Router} from '@angular/router';
 import {TranslateService} from '@ngx-translate/core';
-import {catchError, delay, distinctUntilChanged, filter, map, takeUntil, tap} from 'rxjs/operators';
+import {catchError, delay, distinctUntilChanged, filter, map, skip, takeUntil, tap} from 'rxjs/operators';
 import {AccountService} from './core/auth/account.service';
 import {ApiServiceCheckerService} from './core/auth/api-checker-service';
+import {FederationInstanceStateService} from './federation/services/federation-instance-state.service';
+import {FederationModeService} from './federation/services/federation-mode.service';
 import {MenuBehavior} from './shared/behaviors/menu.behavior';
 import {ThemeChangeBehavior} from './shared/behaviors/theme-change.behavior';
 import {ADMIN_ROLE, USER_ROLE} from './shared/constants/global.constant';
 import {AppThemeLocationEnum} from './shared/enums/app-theme-location.enum';
 import {UtmAppThemeService} from './shared/services/theme/utm-app-theme.service';
 import {AppVersionInfo} from "./shared/types/updates/updates.type";
 import {VersionType, VersionInfoService} from "./shared/services/version/version-info.service";
-import {EMPTY} from "rxjs";
+import {EMPTY, Observable} from "rxjs";
 import {AppVersionService} from './shared/services/version/app-version.service';
 
 @Component({
@@ -32,6 +34,7 @@ export class AppComponent implements OnInit {
   hideStatus = false;
   isAuth = false;
   viewportHeight: number;
+  federationActive$: Observable<boolean>;
 
   constructor(
     private translate: TranslateService,
@@ -42,7 +45,10 @@ export class AppComponent implements OnInit {
     private apiServiceCheckerService: ApiServiceCheckerService,
     private accountService: AccountService,
     private checkForUpdatesService: AppVersionService,
-    private versionTypeService: VersionInfoService) {
+    private versionTypeService: VersionInfoService,
+    private federationInstanceState: FederationInstanceStateService,
+    private federationModeService: FederationModeService) {
+    this.federationActive$ = this.federationModeService.active$;
 
     this.translate.setDefaultLang('en');
 
@@ -82,6 +88,10 @@ export class AppComponent implements OnInit {
       }
     });
 
+    this.federationInstanceState.switch$
+      .pipe(skip(1))
+      .subscribe(() => this.getReportLogo());
+
     this.accountService.getAuthenticationState()
       .pipe(distinctUntilChanged((prev, next) =>  prev && next && prev.id === next.id))
       .subscribe(identity => {

frontend/src/app/app.module.ts

@@ -23,6 +23,7 @@ import {AppComponent} from './app.component';
 import {AuthExpiredInterceptor} from './blocks/interceptor/auth-expired.interceptor';
 import {AuthInterceptor} from './blocks/interceptor/auth.interceptor';
 import {ErrorHandlerInterceptor} from './blocks/interceptor/errorhandler.interceptor';
+import {FederationInstanceInterceptor} from './blocks/interceptor/federation-instance.interceptor';
 import {ManageHttpInterceptor} from './blocks/interceptor/managehttp.interceptor';
 import {NotificationInterceptor} from './blocks/interceptor/notification.interceptor';
 import {HttpCancelService} from './blocks/service/httpcancel.service';
@@ -36,6 +37,8 @@ import {AlertIncidentStatusChangeBehavior} from './shared/behaviors/alert-incide
 import {GettingStartedBehavior} from './shared/behaviors/getting-started.behavior';
 import {NavBehavior} from './shared/behaviors/nav.behavior';
 import {NewAlertBehavior} from './shared/behaviors/new-alert.behavior';
+import {initFederationMode} from './federation/hooks/federation-bootstrap';
+import {FederationModeService} from './federation/services/federation-mode.service';
 import {TimezoneFormatService} from './shared/services/utm-timezone.service';
 import {AppVersionService} from './shared/services/version/app-version.service';
 import {UtmSharedModule} from './shared/utm-shared.module';
@@ -109,6 +112,11 @@ export function initTimezoneFormat(apiChecker: ApiServiceCheckerService,
       deps: [SessionStorageService, LocalStorageService],
       multi: true
     },
+    {
+      provide: HTTP_INTERCEPTORS,
+      useClass: FederationInstanceInterceptor,
+      multi: true
+    },
     {
       provide: HTTP_INTERCEPTORS,
       useClass: AuthExpiredInterceptor,
@@ -132,6 +140,12 @@ export function initTimezoneFormat(apiChecker: ApiServiceCheckerService,
       useClass: ManageHttpInterceptor,
       multi: true,
     },
+    {
+      provide: APP_INITIALIZER,
+      useFactory: initFederationMode,
+      deps: [FederationModeService],
+      multi: true
+    },
     {
       provide: APP_INITIALIZER,
       useFactory: initTimezoneFormat,

frontend/src/app/blocks/interceptor/federation-instance.interceptor.ts

@@ -0,0 +1,53 @@
+import {HttpEvent, HttpHandler, HttpInterceptor, HttpRequest} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {Observable} from 'rxjs';
+import {SERVER_API_URL} from '../../app.constants';
+import {FederationInstanceStateService} from '../../federation/services/federation-instance-state.service';
+import {FederationModeService} from '../../federation/services/federation-mode.service';
+
+const AUTH_PATH_PREFIXES = [
+  'api/authenticate',
+  'api/v1/auth/',
+  'api/tfa/',
+  'auth/'
+];
+
+@Injectable()
+export class FederationInstanceInterceptor implements HttpInterceptor {
+  constructor(private modeService: FederationModeService,
+              private instanceState: FederationInstanceStateService) {}
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    if (!this.modeService.isActive) {
+      return next.handle(request);
+    }
+    if (!this.isApiRequest(request.url)) {
+      return next.handle(request);
+    }
+    if (this.isAuthEndpoint(request.url)) {
+      return next.handle(request);
+    }
+    const instance = this.instanceState.current;
+    if (!instance) {
+      return next.handle(request);
+    }
+    const cloned = request.clone({
+      setHeaders: {'X-UTM-Instance': String(instance.id)}
+    });
+    return next.handle(cloned);
+  }
+
+  private isApiRequest(url: string): boolean {
+    if (!url) {
+      return false;
+    }
+    if (/^https?:/i.test(url)) {
+      return !!SERVER_API_URL && url.startsWith(SERVER_API_URL);
+    }
+    return true;
+  }
+
+  private isAuthEndpoint(url: string): boolean {
+    return AUTH_PATH_PREFIXES.some(prefix => url.includes(prefix));
+  }
+}

frontend/src/app/core/auth/account.service.ts

@@ -4,6 +4,9 @@ import {Observable, Subject} from 'rxjs';
 
 import {SERVER_API_URL} from '../../app.constants';
 import {HttpCancelService} from '../../blocks/service/httpcancel.service';
+import {FederationInstancesService} from '../../federation/services/federation-instances.service';
+import {FederationInstanceStateService} from '../../federation/services/federation-instance-state.service';
+import {FederationModeService} from '../../federation/services/federation-mode.service';
 import {Account} from '../user/account.model';
 import {AuthServerProvider} from './auth-jwt.service';
 import {extractQueryParamsForNavigation} from "../../shared/util/query-params-to-filter.util";
@@ -18,14 +21,18 @@ export class AccountService {
   private userIdentity: Account;
   private authenticated = false;
   private authenticationState = new Subject<any>();
+  private instancesFetchInFlight = false;
 
   constructor(private http: HttpClient,
               private authServerProvider: AuthServerProvider,
               private httpCancelService: HttpCancelService,
               private stateStorageService: StateStorageService,
               private router: Router,
               private spinner: NgxSpinnerService,
-              private utmToast: UtmToastService) {
+              private utmToast: UtmToastService,
+              private federationModeService: FederationModeService,
+              private federationInstancesService: FederationInstancesService,
+              private federationInstanceState: FederationInstanceStateService) {
   }
 
   fetch(): Observable<HttpResponse<Account>> {
@@ -100,10 +107,13 @@ export class AccountService {
         if (account) {
           this.userIdentity = account;
           this.authenticated = true;
-        } else {
-          this.userIdentity = null;
-          this.authenticated = false;
+          return this.ensureFederationInstancesLoaded().then(() => {
+            this.authenticationState.next(this.userIdentity);
+            return this.userIdentity;
+          });
         }
+        this.userIdentity = null;
+        this.authenticated = false;
         this.authenticationState.next(this.userIdentity);
         return this.userIdentity;
       })
@@ -141,17 +151,43 @@ export class AccountService {
     }
   }
 
+  private ensureFederationInstancesLoaded(): Promise<void> {
+    if (!this.federationModeService.isActive) {
+      return Promise.resolve();
+    }
+    if (this.federationInstanceState.instances.length > 0) {
+      return Promise.resolve();
+    }
+    if (this.instancesFetchInFlight) {
+      return Promise.resolve();
+    }
+    this.instancesFetchInFlight = true;
+    return this.federationInstancesService.list()
+      .toPromise()
+      .then(instances => {
+        this.instancesFetchInFlight = false;
+        this.federationInstanceState.setInstances(instances || []);
+      })
+      .catch(() => {
+        this.instancesFetchInFlight = false;
+      });
+  }
+
   startNavigation() {
     this.identity(true).then(account => {
       if (account) {
+        if (this.federationModeService.isActive && this.federationInstanceState.instances.length === 0) {
+          this.router.navigate(['/federation/welcome'])
+            .then(() => this.spinner.hide());
+          return;
+        }
         const { path, queryParams } =
           extractQueryParamsForNavigation(this.stateStorageService.getUrl() ? this.stateStorageService.getUrl() : '' );
         if (path) {
           this.stateStorageService.resetPreviousUrl();
         }
         const redirectTo = (account.authorities.includes(ADMIN_ROLE) && account.email === ADMIN_DEFAULT_EMAIL)
           ? '/getting-started' : !!path ? path : '/dashboard/overview';
-        console.log(redirectTo);
         this.router.navigate([redirectTo], {queryParams})
           .then(() => this.spinner.hide());
       } else {

frontend/src/app/core/auth/user-route-access-service.ts

@@ -2,15 +2,21 @@ import {Injectable, isDevMode} from '@angular/core';
 import {ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot} from '@angular/router';
 import {ModalService} from '../modal/modal.service';
 
+import {FederationInstanceStateService} from '../../federation/services/federation-instance-state.service';
+import {FederationModeService} from '../../federation/services/federation-mode.service';
 import {AccountService} from './account.service';
 import {StateStorageService} from './state-storage.service';
 
+const FEDERATION_WELCOME_URL = '/federation/welcome';
+
 @Injectable({providedIn: 'root'})
 export class UserRouteAccessService implements CanActivate {
   constructor(
     private router: Router,
     private accountService: AccountService,
-    private stateStorageService: StateStorageService
+    private stateStorageService: StateStorageService,
+    private federationModeService: FederationModeService,
+    private federationInstanceState: FederationInstanceStateService
   ) {
   }
 
@@ -28,6 +34,14 @@ export class UserRouteAccessService implements CanActivate {
       return false;
     }
     if (account) {
+      if (
+        this.federationModeService.isActive &&
+        this.federationInstanceState.instances.length === 0 &&
+        !url.startsWith(FEDERATION_WELCOME_URL)
+      ) {
+        this.router.navigate([FEDERATION_WELCOME_URL]);
+        return false;
+      }
       const hasAnyAuthority = this.accountService.hasAnyAuthority(authorities);
       if (hasAnyAuthority) {
         return true;