vix-ui/fesm2015/vix-ui.js

A set of essential UI modules for your Angular application in ViSenze

import { Injectable, NgModule, ChangeDetectorRef, Component, NgZone } from '@angular/core';
import { HttpClient, HttpHeaders, HttpClientModule } from '@angular/common/http';
import { __awaiter } from 'tslib';
import { OAuthService, UrlHelperService } from 'angular-oauth2-oidc';
import * as OktaAuth from '@okta/okta-auth-js';
import { Router } from '@angular/router';
import { CommonModule } from '@angular/common';
import { FormControl, Validators, FormsModule, ReactiveFormsModule } from '@angular/forms';
import { MatButtonModule, MatFormFieldModule, MatIconModule, MatInputModule, MatProgressBarModule } from '@angular/material';
import { BrowserAnimationsModule, NoopAnimationsModule } from '@angular/platform-browser/animations';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * VixAuthConfig holds the necessary config required by other services
 */
class VixAuthConfig {
}
/**
 * AuthConfigService provides get method for all parameters
 *
 * \@var {string} _url: url for okta account like: 'https://dev-913444.oktapreview.com'
 * \@
 */
class AuthConfigService {
    /**
     * @param {?} authConfig
     */
    constructor(authConfig) {
        this.authConfig = authConfig;
        this._url = authConfig.url;
        this._issuer = authConfig.issuer;
        this._clientId = authConfig.clientId;
        this._redirectUrl = authConfig.redirectUrl;
        this._apiKey = authConfig.apiKey;
        this._loginUrl = authConfig.loginUrl;
    }
    /**
     * @return {?}
     */
    getLoginUrl() {
        return this._loginUrl;
    }
    /**
     * @return {?} url
     */
    getUrl() {
        return this._url;
    }
    /**
     * @return {?} issuer
     */
    getIssuer() {
        return this._issuer;
    }
    /**
     * @return {?} clientId
     */
    getClientId() {
        return this._clientId;
    }
    /**
     *
     * @return {?} redirectUrl
     */
    getRedirectUrl() {
        return this._redirectUrl;
    }
    /**
     *
     * @return {?} remove the domain from url.
     * example: return '/foo/bar' if redirectUrl is 'http://foobar.com/foo/bar'
     */
    getRoute() {
        const /** @type {?} */ s = this._redirectUrl.split('/');
        return '/' + s.slice(3, s.length).join('/');
    }
    /**
     * @return {?} okta API key
     */
    getApiKey() {
        return this._apiKey;
    }
}
AuthConfigService.decorators = [
    { type: Injectable },
];
/** @nocollapse */
AuthConfigService.ctorParameters = () => [
    { type: VixAuthConfig, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * Wrapper for Okta API
 */
class OktaService {
    /**
     * @param {?} httpClient
     * @param {?} authConfig
     */
    constructor(httpClient, authConfig) {
        this.httpClient = httpClient;
        this.authConfig = authConfig;
        this.httpOptions = {
            headers: new HttpHeaders({
                'Content-Type': 'application/json',
                'Accept': 'application/json',
                'Authorization': 'SSWS ' + this.authConfig.getApiKey()
            })
        };
    }
    /**
     * Build Full API URl by given endpoint
     * @param {?} endpoint
     * @return {?}
     */
    getFullUrl(endpoint) {
        return `${this.authConfig.getUrl()}/api/v1${endpoint}`;
    }
    /**
     * Get user info by email.
     * doc: https://developer.okta.com/docs/api/resources/users#get-current-user
     * @param {?} userId
     * @return {?}
     */
    getUserInfo(userId) {
        return this.httpClient.get(this.getFullUrl(`/users/${userId}`), this.httpOptions).toPromise();
    }
    /**
     * Get user groups information by given userId
     * doc: https://developer.okta.com/docs/api/resources/users#get-member-groups
     * @param {?} userId
     * @return {?}
     */
    getUserGroups(userId) {
        return this.httpClient.get(this.getFullUrl(`/users/${userId}/groups`), this.httpOptions).toPromise();
    }
    /**
     * List all groups
     * @return {?}
     */
    listGroups() {
        return this.httpClient.get(this.getFullUrl('/groups'), this.httpOptions).toPromise();
    }
}
OktaService.decorators = [
    { type: Injectable },
];
/** @nocollapse */
OktaService.ctorParameters = () => [
    { type: HttpClient, },
    { type: AuthConfigService, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * UserInfo holds the user information
 */
class UserInfo {
    /**
     * Extract necessary information oktaUserInfo
     * @param {?} oktaUserInfo
     * oktaUserInfo example:
     * {
     *   "id": "foobar",
     *   ...
     *   "profile": {
     *       "firstName": "foobar",
     *       "lastName": "foobar",
     *       "mobilePhone": null,
     *       "secondEmail": null,
     *       "login": "foo\@bar.com",
     *       "email": "foo\@bar.com"
     *   },
     *   ...
     * }
     */
    constructor(oktaUserInfo) {
        this.userId = oktaUserInfo.id;
        this.email = oktaUserInfo.profile.email;
        this.firstName = oktaUserInfo.profile.firstName;
        this.lastName = oktaUserInfo.profile.lastName;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * UserGroups holds the groups information of a user. It is mainly used to check permissions.
 */
class UserGroups {
    /**
     * construct UserGroups from OktaUserGroups
     *
     * @param {?} oktaUserGroups Array of oktaGroups
     * oktaGroup example:
     * { ...
     *   "profile": {
     *     "name": "Everyone",
     *     "description": "All users in your organization"
     *   },
     *   ...
     * }
     */
    constructor(oktaUserGroups) {
        this.groups = [];
        if (oktaUserGroups) {
            oktaUserGroups.forEach((oktaGroup) => {
                this.groups.push(oktaGroup.profile.name);
            });
        }
    }
    /**
     * Check if instance has enough permission for requireGroups.
     *
     * @param {?} requireGroups
     * @return {?} true if this.groups contains all group of requireGroups, else then false
     */
    hasPermission(requireGroups) {
        for (let /** @type {?} */ i = 0; i < requireGroups.length; i++) {
            if (this.groups.indexOf(requireGroups[i]) > 0) {
                return true;
            }
        }
        return false;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * VixAuthService is the interface exported to users. It wraps all API and methods.
 */
class VixAuthService {
    /**
     * @param {?} oauth
     * @param {?} authConfig
     * @param {?} okta
     */
    constructor(oauth, authConfig, okta) {
        this.oauth = oauth;
        this.authConfig = authConfig;
        this.okta = okta;
        this.oktaAuth = new OktaAuth({
            url: this.authConfig.getUrl(),
            issuer: this.authConfig.getIssuer()
        });
    }
    /**
     * Check permissions by userGroups and requireGroups
     *
     * @param {?} userGroups groups users are in
     * @param {?} requireGroups groups application requires user to have
     * @return {?} true/false
     */
    static hasPermission(userGroups, requireGroups) {
        return userGroups.hasPermission(requireGroups);
    }
    /**
     * Use tokenManager to store userId
     * TODO: actually I have problems in create a cache object to hold all these cache variables, so I use tokenManager to do these works.
     * TODO: need to create a share service to provide cache service
     *
     * @param {?} userId
     * @return {?}
     */
    setUserId(userId) {
        const /** @type {?} */ obj = {
            accessToken: 'userId',
            expiresAt: Math.round((new Date()).getTime() / 1000 + 3600),
            scopes: [userId]
        };
        this.oktaAuth.tokenManager.add('userId', obj);
    }
    /**
     * Get userId from tokenManager
     * @return {?}
     */
    getUserId() {
        const /** @type {?} */ userIdObj = this.oktaAuth.tokenManager.get('userId');
        if (userIdObj) {
            return this.oktaAuth.tokenManager.get('userId').scopes[0];
        }
        else {
            return null;
        }
    }
    /**
     * Store userGroup and shared among browsers by TokenManager with key 'userGroup'
     *
     * @param {?} userGroups
     * @return {?}
     */
    setCurrentUserGroups(userGroups) {
        const /** @type {?} */ obj = {
            accessToken: 'userGroups',
            expiresAt: Math.round((new Date()).getTime() / 1000 + 3600),
            scopes: userGroups.groups
        };
        this.oktaAuth.tokenManager.add('userGroups', obj);
    }
    /**
     * Get stored userGroups and refresh if expires
     *
     * @return {?}
     */
    getLoginUserGroups() {
        return __awaiter(this, void 0, void 0, function* () {
            const /** @type {?} */ userGroupsTokenObj = this.oktaAuth.tokenManager.get('userGroups');
            const /** @type {?} */ nowSecond = (new Date()).getTime() / 1000;
            if (!userGroupsTokenObj || nowSecond > userGroupsTokenObj.expireAt) {
                const /** @type {?} */ tmpUserGroups = yield this.getUserGroups(this.getUserId());
                this.setCurrentUserGroups(tmpUserGroups);
            }
            const /** @type {?} */ userGroups = new UserGroups(null);
            userGroups.groups = this.oktaAuth.tokenManager.get('userGroups').scopes;
            return userGroups;
        });
    }
    /**
     * Get current login userInfo
     * TODO: we can cache user info includes groups information when finished login
     *
     * @return {?}
     */
    getUserInfo() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.isLogin()) {
                const /** @type {?} */ oktaUserInfo = yield this.okta.getUserInfo(this.getUserId());
                return yield new UserInfo(oktaUserInfo);
            }
            else {
                return Promise.reject('not login');
            }
        });
    }
    /**
     * get userGroup by given userId
     *
     * @param {?} userId
     * @return {?}
     */
    getUserGroups(userId) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.isLogin()) {
                try {
                    const /** @type {?} */ oktaUserGroups = yield this.okta.getUserGroups(userId);
                    return yield new UserGroups(oktaUserGroups);
                }
                catch (/** @type {?} */ err) {
                    console.log('getUserGroups err', err);
                    // return new UserGroups(null);
                }
            }
            else {
                return null;
            }
        });
    }
    /**
     * Return if already login by check the existence of accessToken
     *
     * @return {?}
     */
    isLogin() {
        return !!this.getUserId();
    }
    /**
     * Redirect to url for Google login
     * @param {?} redirectUrl
     * @return {?}
     */
    loginWithGoogle(redirectUrl) {
        window.location.href = `${this.authConfig.getUrl()}/oauth2/v1/authorize?` +
            `idp=0oadulhuz78SMW8cD0h7&client_id=${this.authConfig.getClientId()}&response_type=id_token&` +
            `response_mode=fragment&scope=openid&scope=email&scope=picture&scope=name&` +
            `state=WM6D&nonce=YsG76jo&redirect_uri=${redirectUrl}`;
    }
    /**
     * Login by username and password
     *
     * @param {?} username
     * @param {?} password
     * @return {?}
     */
    loginWithPassword(username, password) {
        return __awaiter(this, void 0, void 0, function* () {
            const /** @type {?} */ nonce = yield this.oauth.createAndSaveNonce();
            const /** @type {?} */ signInResponse = yield this.oktaAuth.signIn({ username: username, password: password });
            if (signInResponse.status === 'SUCCESS') {
                yield this.oktaAuth.token.getWithoutPrompt({
                    clientId: this.authConfig.getClientId(),
                    responseType: ['id_token', 'token'],
                    scopes: ['openid', 'profile', 'email'],
                    sessionToken: signInResponse.sessionToken,
                    nonce: nonce,
                    redirectUri: window.location.origin
                });
                const /** @type {?} */ session = yield this.getSession();
                if (session.status === 'ACTIVE') {
                    console.log('session ACTIVE');
                    this.setUserId(session.userId);
                }
                return Promise.resolve('login successfully');
            }
            else {
                return Promise.reject('username or password error');
            }
        });
    }
    /**
     * List all groups
     *
     * @return {?}
     */
    listGroups() {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.okta.listGroups();
        });
    }
    /**
     * Get session
     *
     * @return {?}
     */
    getSession() {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.oktaAuth.session.get();
        });
    }
    /**
     * Navigate browser to login page
     * @return {?}
     */
    navigateToLoginPage() {
        console.log('navigateToLoginPage:', this.authConfig.getLoginUrl());
        document.location.href = this.authConfig.getLoginUrl();
    }
    /**
     * Navigate browser to redirect page
     * @return {?}
     */
    navigateToRedirectPage() {
        console.log('navigateToRedirectPage:', this.authConfig.getRedirectUrl());
        document.location.href = this.authConfig.getRedirectUrl();
    }
    /**
     * Logout current user and clear token
     *
     * @return {?}
     */
    logout() {
        if (this.isLogin()) {
            this.oktaAuth.tokenManager.clear();
            console.log('start to logout');
            this.oktaAuth.signOut().then(() => {
                console.log('logout done, to navigate', this.authConfig.getLoginUrl());
                this.navigateToLoginPage();
            });
        }
    }
}
VixAuthService.decorators = [
    { type: Injectable },
];
/** @nocollapse */
VixAuthService.ctorParameters = () => [
    { type: OAuthService, },
    { type: AuthConfigService, },
    { type: OktaService, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * Auth guard will check user groups and app required groups and
 * judge user can view the route or not
 */
class VixAuthGuard {
    /**
     * @param {?} auth
     * @param {?} authConfig
     * @param {?} router
     */
    constructor(auth, authConfig, router) {
        this.auth = auth;
        this.authConfig = authConfig;
        this.router = router;
    }
    /**
     * compare user groups and app required groups by UserGroups.hasPermission()
     * canActive will cache the user groups information by 1 hour.
     *
     * @param {?} route
     * @param {?} state
     * @return {?}
     */
    canActivate(route, state) {
        return __awaiter(this, void 0, void 0, function* () {
            console.log('in authguard');
            if (!this.auth.isLogin()) {
                alert('Please login first.');
                this.auth.navigateToLoginPage();
                return false;
            }
            const /** @type {?} */ currentUserGroups = yield this.auth.getLoginUserGroups();
            const /** @type {?} */ requireGroups = /** @type {?} */ (route.data['groups']);
            if (VixAuthService.hasPermission(currentUserGroups, requireGroups)) {
                return true;
            }
            alert('Insufficient permissions. Please contact renjie@visenze.com');
            // this.auth.navigateToLoginPage();
            this.auth.navigateToRedirectPage();
            return false;
        });
    }
}
VixAuthGuard.decorators = [
    { type: Injectable },
];
/** @nocollapse */
VixAuthGuard.ctorParameters = () => [
    { type: VixAuthService, },
    { type: AuthConfigService, },
    { type: Router, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class VixAuthModule {
    /**
     * @param {?} config
     * @return {?}
     */
    static forRoot(config) {
        return {
            ngModule: VixAuthModule,
            providers: [
                { provide: VixAuthConfig, useValue: config }
            ]
        };
    }
}
VixAuthModule.decorators = [
    { type: NgModule, args: [{
                imports: [
                    CommonModule,
                    HttpClientModule,
                ],
                providers: [
                    OktaService,
                    VixAuthService,
                    AuthConfigService,
                ],
                declarations: [],
                exports: []
            },] },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class VixLoginComponent {
    /**
     * @param {?} oauth
     * @param {?} auth
     * @param {?} router
     * @param {?} authConfig
     * @param {?} cdRef
     * @param {?} ngZone
     */
    constructor(oauth, auth, router, authConfig, cdRef, ngZone) {
        this.oauth = oauth;
        this.auth = auth;
        this.router = router;
        this.authConfig = authConfig;
        this.cdRef = cdRef;
        this.ngZone = ngZone;
        this.loginFormControl = new FormControl('', [Validators.required, Validators.email]);
        this.isShowProgressBar = false;
        this.isShowProgressBar = false;
        if (this.auth.isLogin()) {
            console.log('already login in login page');
            this.ngZone.run(() => {
                this.auth.navigateToRedirectPage();
            });
        }
    }
    /**
     * @param {?} status
     * @return {?}
     */
    toggleProgressBar(status) {
        this.isShowProgressBar = status;
    }
    /**
     * Form control to validate email
     *
     * @return {?}
     */
    getErrorMessage() {
        return this.loginFormControl.hasError('required') ? 'You must enter a value' :
            this.loginFormControl.hasError('email') ? 'Not a valid email' :
                '';
    }
    /**
     * Login with Google
     * @return {?}
     */
    loginWithGoogle() {
        this.auth.loginWithGoogle(this.authConfig.getLoginUrl());
    }
    /**
     * Login with username and password. Redirect to url after login successfully
     * @return {?}
     */
    loginWithPassword() {
        if (this.loginFormControl.invalid) {
            alert('Email is not valid!');
            return;
        }
        this.toggleProgressBar(true);
        this.auth.loginWithPassword(this.email, this.password)
            .then(() => {
            // this.router.navigate([this.authConfig.getRoute()]);
            this.auth.navigateToRedirectPage();
        })
            .catch(err => {
            this.toggleProgressBar(false);
            console.log('login with username and password failed', err);
            alert('Username or Password error, cannot login');
        });
    }
    /**
     * @return {?}
     */
    ngAfterViewChecked() {
        this.cdRef.detectChanges();
    }
    /**
     * This is used for Google Login. Browser will redirect to the login url after login successfully.
     * ngAfterViewInit will get the access_token from url and redirect to the url set as redirect url.
     * @return {?}
     */
    ngAfterViewInit() {
        const /** @type {?} */ regexp = new RegExp('[#|\?]id_token=([^&]*)[&]{0,1}');
        const /** @type {?} */ idTokenRegex = regexp.exec(this.router.url);
        if (idTokenRegex) {
            console.log('has idToken', idTokenRegex);
            this.toggleProgressBar(true);
            // has idToken in url
            this.auth.getSession().then(session => {
                if (session.status === 'ACTIVE') {
                    console.log('session ACTIVE');
                    this.auth.setUserId(session.userId);
                    this.ngZone.run(() => {
                        this.auth.navigateToRedirectPage();
                    });
                }
                else {
                    console.log('session INACTIVE');
                    this.ngZone.run(() => {
                        this.auth.navigateToLoginPage();
                    });
                }
            });
        }
    }
}
VixLoginComponent.decorators = [
    { type: Component, args: [{
                selector: 'vix-log-in',
                template: `<title>ViSenze Sign In</title>
<div class="background">
  <img class="logo" src="data:image/jpeg;base64,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