vc-error-handlers 0.1.95 → 0.1.97

package/fesm2020/vc-error-handlers.mjs

@@ -6,9 +6,10 @@ import { NavigationStart, NavigationEnd, NavigationError } from '@angular/router
 import * as i1 from '@vcomply/authorizer';
 import * as i2 from '@angular/common';
 import { CommonModule } from '@angular/common';
+import * as i1$1 from '@angular/common/http';
 import { HttpResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { retry, timeout, tap, catchError } from 'rxjs/operators';
 import * as Sentry from '@sentry/angular-ivy';
-import { timeout, tap, catchError } from 'rxjs/operators';
 
 class VcErrorHandlersService {
     constructor() { }
@@ -189,7 +190,7 @@ const COMPONENT_LEVEL_API_CONFIG = [
     },
     {
         method: 'POST',
-        path: '/organization_post/?mode=memberDetailsbyIds',
+        path: '/organization_post?mode=memberDetailsbyIds',
         query: null,
         body: null,
     },
@@ -213,8 +214,8 @@ const COMPONENT_LEVEL_API_CONFIG = [
     },
     {
         method: 'POST',
-        path: '/risk?mode=risk/list',
-        query: { queryPage: 'compliance_workroom' },
+        path: 'risk/list',
+        query: null,
         body: null,
     },
     {
@@ -271,6 +272,18 @@ const COMPONENT_LEVEL_API_CONFIG = [
         query: null,
         body: null,
     },
+    {
+        method: 'GET',
+        path: '/program/subCategories',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/Assessment/?mode=assessment/getAssessmentById',
+        query: null,
+        body: null,
+    },
 ];
 
 class SnackBarService {
@@ -413,16 +426,16 @@ class GlobalErrorService {
         params.keys().forEach((key) => {
             query[key] = params.get(key);
         });
-        console.log('query', query, 'body', body, 'path', path, 'method', method, 'params', params);
         const isConfigFound = this.componentLevelApiConfig.some((apiConfig) => {
             if (apiConfig.method !== method)
                 return false;
-            console.log('apiConfig.path', apiConfig.path, path.includes(apiConfig.path));
             if (!path.includes(apiConfig.path))
                 return false;
-            const isQuerySubset = this.utilService.isJsonSubset(query, apiConfig.query);
-            if (!isQuerySubset)
-                return false;
+            if (apiConfig.query) {
+                const isQuerySubset = this.utilService.isJsonSubset(query, apiConfig.query);
+                if (!isQuerySubset)
+                    return false;
+            }
             if (apiConfig.body) {
                 const isBodyMatch = this.utilService.isJsonSubset(apiConfig.body, body);
                 if (!isBodyMatch)
@@ -1273,6 +1286,212 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
                 }]
         }] });
 
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build --prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+let domainName = 'devapi.v-comply.com';
+let apiBaseUrl = 'https://api-uat1.v-comply.com';
+switch (window.location.host) {
+    case 'dev.v-comply.com':
+        domainName = 'devapi.v-comply.com';
+        apiBaseUrl = 'https://api-uat1.v-comply.com';
+        break;
+    case 'beta.v-comply.com':
+        domainName = 'betaapi.v-comply.com';
+        apiBaseUrl = 'https://api-staging.v-comply.com';
+        break;
+    case 'test.v-comply.com':
+        domainName = 'devapi.v-comply.com';
+        break;
+    case 'eu.v-comply.com':
+        domainName = 'euapi.v-comply.com';
+        break;
+    default:
+        domainName = 'api.v-comply.com';
+        break;
+}
+const PORT_EDITOR = 8081;
+const PORT_CONTENT_SAVE = 8834;
+let endPoint = 'https://devapi.v-comply.com/';
+const environment = {
+    production: false,
+    appUrl: 'http://localhost:4200/',
+    apiBaseUrl: 'https://api-uat1.v-comply.com',
+    authEndpoint: `${endPoint}VcomplyAuth/`,
+    orgEndpoint_TL: `${endPoint}organization_pwt/?mode=`,
+    s3Url: '',
+    s3BucketUrl: `${endPoint}globals?mode=bucket`,
+    s3Bucket: '',
+    profile: '/profile_pic/thumb/',
+    assessmentEnpoint: `${endPoint}Assessment/?mode=`,
+    organizationPost: `${endPoint}organization_post/?mode=`,
+    organizationGet: `${endPoint}organization/?mode=`,
+    complianceGet: `${endPoint}compliance/?mode=`,
+    compliancePost: `${endPoint}compliance_post/?mode=`,
+    fileUploadEndPoint: 'https://upload-uat1.v-comply.com/fileupload/?destination=',
+    assuranceGet: `${endPoint}assurance/?mode=`,
+    policyGet: `${endPoint}policy/?mode=`,
+    saveDoc: 'https://dev-node.v-comply.com/saveContent?bypass-token=true&id=',
+    docxUpload: 'https://dev-node.v-comply.com/ImportDocument',
+    fileUpload: 'https://dev-node.v-comply.com/importFiles',
+    policyPost: `${endPoint}policy_post/?mode=`,
+    policyPut: `${endPoint}policy_put/?mode=`,
+    responsibilityPost: `${endPoint}responsibilities_post/?mode=`,
+    linkDoc: 'https://dev-node.v-comply.com' + '/ImportDocument',
+    linkPdf: 'https://dev-node.v-comply.com' + '/extractDocs',
+    assuranceApi: 'https://devapi.v-comply.com/Assurance/',
+    assurance: 'https://devapi.v-comply.com/Assurance/',
+    programEndpoint: 'https://devapi.v-comply.com/program',
+    risk: 'https://devapi.v-comply.com/risk/?mode=',
+    risk_put: 'https://devapi.v-comply.com/risk_put/?mode=',
+    riskPdfPost: 'https://devapi.v-comply.com/risk_pdf_post?mode=',
+    riskPost: 'https://devapi.v-comply.com/risk_post/?mode=',
+    riskGet: 'https://devapi.v-comply.com/risk/?mode=',
+    baseUrl: 'https://devapi.v-comply.com/',
+    grc_get: 'https://devapi.v-comply.com/grc_object/?mode=',
+    leftMenuLogo: 'https://cdn.v-comply.com/logo/prod/v-logo.svg?v=1.0',
+    vLoader: 'https://cdn.v-comply.com/logo/prod/v-icon-loader.svg?v=1.0',
+};
+/*
+ * For easier debugging in development mode, you can import the following file
+ * to ignore zone related error stack frames such as `zone.run`, `zoneDelegate.invokeTask`.
+ *
+ * This import should be commented out in production mode because it will have a negative impact
+ * on performance if an error is thrown.
+ */
+// import 'zone.js/plugins/zone-error';  // Included with Angular CLI.
+
+class FeatureFlagService {
+    constructor(http, authorizer) {
+        this.http = http;
+        this.authorizer = authorizer;
+        this.flagFetchError = false;
+        this.featuresMap = {};
+        this.AWSFlags = {};
+    }
+    fetchFlags() {
+        return this.http.get(environment.baseUrl + 'features').pipe(retry(2));
+    }
+    loadConfig() {
+        if (this.flagSubscription) {
+            this.flagSubscription.unsubscribe();
+        }
+        return new Promise((resolve, reject) => {
+            this.flagSubscription = this.fetchFlags().subscribe({
+                next: (res) => {
+                    try {
+                        resolve(true);
+                        this.flagFetchError = false;
+                        this.AWSFlags = res;
+                        this.buildFeatureFlags(this.authorizer.getOrganizationId());
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                error: (err) => {
+                    reject(true);
+                    this.flagFetchError = true;
+                    console.log('An error occurred while fetching feature flags', err);
+                },
+            });
+        });
+    }
+    buildFeatureFlags(orgId) {
+        orgId = orgId?.toString();
+        const enabledFeatures = {};
+        Object.keys(this.AWSFlags).forEach((flag) => {
+            const flagObj = this.AWSFlags[flag];
+            enabledFeatures[flag] = false;
+            if (flagObj) {
+                if (flagObj?.enabled && !flagObj.hasOwnProperty('enabledOrgIds')) {
+                    enabledFeatures[flag] = true;
+                }
+                else if (flagObj?.enabled &&
+                    flagObj.hasOwnProperty('enabledOrgIds') &&
+                    flagObj?.enabledOrgIds?.length > 0) {
+                    if (flagObj?.enabledOrgIds?.includes(orgId)) {
+                        enabledFeatures[flag] = true;
+                    }
+                    else {
+                        enabledFeatures[flag] = false;
+                    }
+                }
+                else {
+                    if (flagObj?.enabled) {
+                        enabledFeatures[flag] = true;
+                    }
+                    else {
+                        enabledFeatures[flag] = false;
+                    }
+                }
+            }
+            else {
+                enabledFeatures[flag] = true;
+            }
+        });
+        this.featuresMap = enabledFeatures;
+    }
+    isFeatureEnabled(featureFlag) {
+        if (this.featuresMap.hasOwnProperty(featureFlag)) {
+            return this.featuresMap[featureFlag];
+        }
+        else {
+            return true;
+        }
+    }
+}
+FeatureFlagService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagService, deps: [{ token: i1$1.HttpClient }, { token: i1.AuthorizerService }], target: i0.ɵɵFactoryTarget.Injectable });
+FeatureFlagService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.HttpClient }, { type: i1.AuthorizerService }]; } });
+
+class FeatureFlagDirective {
+    constructor(tpl, vcr, featureFlagService) {
+        this.tpl = tpl;
+        this.vcr = vcr;
+        this.featureFlagService = featureFlagService;
+    }
+    ngOnInit() {
+        const isEnabled = this.featureFlagService.isFeatureEnabled(this.featureFlag);
+        if (isEnabled) {
+            this.vcr.createEmbeddedView(this.tpl);
+        }
+    }
+}
+FeatureFlagDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: FeatureFlagService }], target: i0.ɵɵFactoryTarget.Directive });
+FeatureFlagDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: FeatureFlagDirective, selector: "[featureFlag]", inputs: { featureFlag: "featureFlag" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[featureFlag]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: FeatureFlagService }]; }, propDecorators: { featureFlag: [{
+                type: Input
+            }] } });
+
+class FeatureFlagModule {
+}
+FeatureFlagModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FeatureFlagModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagModule, declarations: [FeatureFlagDirective], imports: [CommonModule], exports: [FeatureFlagDirective] });
+FeatureFlagModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: FeatureFlagModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FeatureFlagDirective],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [FeatureFlagDirective]
+                }]
+        }] });
+
 class Configurations {
     constructor() {
         this.sentryConfig = {};
@@ -1323,28 +1542,38 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
                 }] }]; } });
 
 class HttpReqInterceptor {
-    constructor(errorService) {
+    constructor(errorService, featureFlagService) {
         this.errorService = errorService;
+        this.featureFlagService = featureFlagService;
     }
     intercept(req, next) {
-        return next.handle(req).pipe(timeout(API_TIMEOUT_TIME), tap((event) => {
-            if (event instanceof HttpResponse) {
-                this.errorService.handleSoftErrors(event);
-            }
-        }), catchError((error) => {
-            this.errorService.handleError(error, req);
-            return throwError(error);
-        }));
+        if (this.featureFlagService.isFeatureEnabled('ff_error_handling')) {
+            return next.handle(req).pipe(timeout(API_TIMEOUT_TIME), tap((event) => {
+                if (event instanceof HttpResponse) {
+                    this.errorService.handleSoftErrors(event);
+                }
+            }), catchError((error) => {
+                this.errorService.handleError(error, req);
+                return throwError(error);
+            }));
+        }
+        else {
+            return next.handle(req);
+        }
     }
 }
-HttpReqInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: HttpReqInterceptor, deps: [{ token: GlobalErrorService }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpReqInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: HttpReqInterceptor, deps: [{ token: GlobalErrorService }, { token: FeatureFlagService }], target: i0.ɵɵFactoryTarget.Injectable });
 HttpReqInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: HttpReqInterceptor });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: HttpReqInterceptor, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: GlobalErrorService }]; } });
+        }], ctorParameters: function () { return [{ type: GlobalErrorService }, { type: FeatureFlagService }]; } });
 
 const FOR_ROOT_SENTRY_OPTIONS_TOKEN = new InjectionToken('forRoot() SentryErrorHandler options');
 class VcErrorHandlersModule {
+    constructor(loadConfig) {
+        this.loadConfig = loadConfig;
+        this.loadConfig.loadConfig();
+    }
     static forRoot(environmentConfig) {
         return {
             ngModule: VcErrorHandlersModule,
@@ -1352,7 +1581,7 @@ class VcErrorHandlersModule {
         };
     }
 }
-VcErrorHandlersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: VcErrorHandlersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VcErrorHandlersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: VcErrorHandlersModule, deps: [{ token: FeatureFlagService }], target: i0.ɵɵFactoryTarget.NgModule });
 VcErrorHandlersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: VcErrorHandlersModule, bootstrap: [VcErrorHandlersComponent], declarations: [VcErrorHandlersComponent,
         PageNotFoundComponent,
         UnauthorizedComponent,
@@ -1360,7 +1589,7 @@ VcErrorHandlersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", v
         ChunkUnavailableComponent,
         ServerErrorComponent,
         ErrorModalComponent,
-        ComponentLevelServerErrorComponent], imports: [CommonModule, DialogModule, SnackBarModule], exports: [VcErrorHandlersComponent,
+        ComponentLevelServerErrorComponent], imports: [CommonModule, DialogModule, SnackBarModule, FeatureFlagModule], exports: [VcErrorHandlersComponent,
         PageNotFoundComponent,
         UnauthorizedComponent,
         SessionExpiredComponent,
@@ -1371,7 +1600,7 @@ VcErrorHandlersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", v
 VcErrorHandlersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: VcErrorHandlersModule, providers: [
         { provide: ErrorHandler, useClass: SentryErrorHandler },
         { provide: HTTP_INTERCEPTORS, useClass: HttpReqInterceptor, multi: true },
-    ], imports: [[CommonModule, DialogModule, SnackBarModule]] });
+    ], imports: [[CommonModule, DialogModule, SnackBarModule, FeatureFlagModule]] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: VcErrorHandlersModule, decorators: [{
             type: NgModule,
             args: [{
@@ -1385,7 +1614,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
                         ErrorModalComponent,
                         ComponentLevelServerErrorComponent,
                     ],
-                    imports: [CommonModule, DialogModule, SnackBarModule],
+                    imports: [CommonModule, DialogModule, SnackBarModule, FeatureFlagModule],
                     exports: [
                         VcErrorHandlersComponent,
                         PageNotFoundComponent,
@@ -1402,7 +1631,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
                     ],
                     bootstrap: [VcErrorHandlersComponent],
                 }]
-        }] });
+        }], ctorParameters: function () { return [{ type: FeatureFlagService }]; } });
 
 /*
  * Public API Surface of vc-error-handlers