@asgardeo/auth-angular
Version:
Asgardeo Auth Angular SDK for Angular Applications.
68 lines • 8.31 kB
JavaScript
/**
* Copyright (c) 2021, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
import { Inject, Injectable } from "@angular/core";
import { from } from "rxjs";
import { catchError, mergeMap } from "rxjs/operators";
import { ASGARDEO_CONFIG } from "../configs/asgardeo-config";
import { AsgardeoAuthService } from "../services/asgardeo-auth.service";
export class AsgardeoAuthInterceptor {
constructor(auth, authConfig) {
this.auth = auth;
this.authConfig = authConfig;
}
intercept(request, next) {
if (this.canAttachToken(request, this.authConfig["resourceServerURLs"])) {
return from(this.auth.getAccessToken())
.pipe(mergeMap(token => {
if (token) {
const header = "Bearer " + token;
const headers = request.headers.set("Authorization", header);
request = request.clone({ headers });
}
return next.handle(request);
}), catchError(error => {
console.error(error);
return next.handle(request);
}));
}
else {
return next.handle(request);
}
}
canAttachToken(request, allowedUrls) {
let matches = false;
if (allowedUrls) {
allowedUrls.forEach((baseUrl) => {
var _a;
if ((_a = request.url) === null || _a === void 0 ? void 0 : _a.startsWith(baseUrl)) {
matches = true;
}
});
}
return matches;
}
}
AsgardeoAuthInterceptor.decorators = [
{ type: Injectable }
];
AsgardeoAuthInterceptor.ctorParameters = () => [
{ type: AsgardeoAuthService },
{ type: undefined, decorators: [{ type: Inject, args: [ASGARDEO_CONFIG,] }] }
];
//# sourceMappingURL=data:application/json;base64,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