import {Injectable} from '@angular/core';

import {

ActivatedRouteSnapshot, CanActivate, CanMatch,

Route, Router, RouterStateSnapshot, UrlTree

} from '@angular/router';

import {AuthService} from './auth.service';

export class AuthGuard implements CanActivate, CanMatch {

// #enddocregion

// #docregion can-match

canMatch(route: Route) {

const url = `/${route.path}`;

return this.checkLogin(url) === true;

}

// #enddocregion can-match

// #docregion

if (this.authService.isLoggedIn) {

return true;

}

**Note:** The guard can also tell the router to navigate elsewhere, effectively canceling the current navigation.

When doing so inside a guard, the guard should return `UrlTree`;

| [`CanMatch`](api/router/CanMatch) | To control whether a `Route` should be used at all, even if the `path` matches the URL segment. |

With the exception of `CanMatch`, if *any* guard returns false, pending guards that have not completed are canceled, and the entire navigation is canceled. If a `CanMatch` guard returns `false`, the `Router` continues

processing the rest of the `Routes` to see if a different `Route` config matches the URL. You can think of this

as though the `Router` is pretending the `Route` with the `CanMatch` guard did not exist.

<a id="can-match-guard"></a>

As an alternative to using a `CanActivate` guard which redirects the user to a new page if they do not have access, you can instead

use a `CanMatch` guard to control whether the `Router` even attempts to activate a `Route`. This allows you to have

multiple `Route` configurations which share the same `path` but are match based on different conditions. In addition, this approach

can allow the `Router` to match the wildcard `Route` instead.

<code-example path="router/src/app/auth/auth.guard.2.ts" header="src/app/auth/auth.guard.ts (excerpt)" region="can-match"></code-example>

<code-example path="router/src/app/admin/admin-routing.module.2.ts" header="src/app/admin/admin-routing.module.ts (guarded admin route)" region="can-match"></code-example>

export interface CanMatch {

// (undocumented)

canMatch(route: Route, segments: UrlSegment[]): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;

}

canMatch?: Array<Type<CanMatch> | InjectionToken<CanMatchFn>>;

import {catchError, concatMap, first, last, map, mergeMap, scan, switchMap, tap} from 'rxjs/operators';

import {LoadedRouterConfig, Route, Routes} from './models';

import {isImmediateMatch, match, matchWithChecks, noLeftoversInUrl, split} from './utils/config_matching';

return matchWithChecks(rawSegmentGroup, route, segments, injector, this.urlSerializer)

.pipe(

switchMap(({matched, consumedSegments, remainingSegments}) => {

if (!matched) return noMatch(rawSegmentGroup);

// Only create the Route's `EnvironmentInjector` if it matches the attempted

// navigation

injector = getOrCreateRouteInjectorIfNeeded(route, injector);

const childConfig$ = this.getChildConfig(injector, route, segments);

return childConfig$.pipe(mergeMap((routerConfig: LoadedRouterConfig) => {

const childInjector = routerConfig.injector ?? injector;

const childConfig = routerConfig.routes;

const {segmentGroup: splitSegmentGroup, slicedSegments} =

split(rawSegmentGroup, consumedSegments, remainingSegments, childConfig);

// See comment on the other call to `split` about why this is necessary.

const segmentGroup =

new UrlSegmentGroup(splitSegmentGroup.segments, splitSegmentGroup.children);

if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {

const expanded$ = this.expandChildren(childInjector, childConfig, segmentGroup);

return expanded$.pipe(

map((children: any) => new UrlSegmentGroup(consumedSegments, children)));

}

if (childConfig.length === 0 && slicedSegments.length === 0) {

return of(new UrlSegmentGroup(consumedSegments, {}));

}

const matchedOnOutlet = getOutlet(route) === outlet;

const expanded$ = this.expandSegment(

childInjector, segmentGroup, childConfig, slicedSegments,

matchedOnOutlet ? PRIMARY_OUTLET : outlet, true);

return expanded$.pipe(

map((cs: UrlSegmentGroup) => new UrlSegmentGroup(

consumedSegments.concat(cs.segments), cs.children)));

}));

}),

);

export {CanActivate, CanActivateChild, CanDeactivate, CanLoad, CanMatch, Data, LoadChildren, LoadChildrenCallback, QueryParamsHandling, Resolve, ResolveData, Route, Routes, RunGuardsAndResolvers, UrlMatcher, UrlMatchResult} from './models';