vcomply-workflow-engine 3.5.3 → 3.5.4

package/esm2022/lib/sharedComponents/link-program/link-program/program-list-model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3JhbS1saXN0LW1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdngtd29ya2Zsb3ctZW5naW5lL3NyYy9saWIvc2hhcmVkQ29tcG9uZW50cy9saW5rLXByb2dyYW0vbGluay1wcm9ncmFtL3Byb2dyYW0tbGlzdC1tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBwcm9ncmFtTGlzdCB7XHJcbiAgICAgICAgZGF0YTogYW55W10sXHJcbiAgICAgICAgZnJvbTogbnVtYmVyLFxyXG4gICAgICAgIHRvOiBudW1iZXIsXHJcbiAgICAgICAgdG90YWxQYWdlczogbnVtYmVyLFxyXG4gICAgICAgIHRvdGFsUmVjb3JkczogbnVtYmVyLFxyXG4gICAgICAgIGN1cnJlbnRQYWdlOiBudW1iZXIsXHJcbiAgICAgICAgQWxsSW50ZXJuYWxDb250cm9sc1Byb2dyYW1zQ291bnQ6IG51bWJlcixcclxuICAgICAgICBBbGxPdGhlcnNQcm9ncmFtc0NvdW50OiBudW1iZXIsXHJcbiAgICAgICAgQWxsUmVndWxhdGlvblByb2dyYW1zQ291bnQ6IG51bWJlcixcclxuICAgICAgICBBbGxTdGFuZGFyZFByb2dyYW1zQ291bnQ6IG51bWJlcixcclxuICAgICAgICBTZWxlY3RlZEludGVybmFsQ29udHJvbHNQcm9ncmFtc0NvdW50OiBudW1iZXIsXHJcbiAgICAgICAgU2VsZWN0ZWRPdGhlcnNQcm9ncmFtc0NvdW50OiBudW1iZXIsXHJcbiAgICAgICAgU2VsZWN0ZWRSZWd1bGF0aW9uUHJvZ3JhbXNDb3VudDogbnVtYmVyLFxyXG4gICAgICAgIFNlbGVjdGVkU3RhbmRhcmRQcm9ncmFtc0NvdW50OiBudW1iZXJcclxufVxyXG5leHBvcnQgaW50ZXJmYWNlIGNhdGVnb3J5TGlzdCB7XHJcbiAgICBkYXRhOmFueSBbXSxcclxuICAgIGZyb206IG51bWJlcixcclxuICAgIHRvOiBudW1iZXIsXHJcbiAgICB0b3RhbFBhZ2VzOiBudW1iZXIsXHJcbiAgICB0b3RhbFJlY29yZHM6IG51bWJlcixcclxuICAgIGN1cnJlbnRQYWdlOiBudW1iZXIsXHJcbiAgICBzZWxlY3RlZENhdGVnb3JpZXM6YW55W11cclxufSJdfQ==

package/esm2022/lib/sharedComponents/link-program/program-integration-interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3JhbS1pbnRlZ3JhdGlvbi1pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdngtd29ya2Zsb3ctZW5naW5lL3NyYy9saWIvc2hhcmVkQ29tcG9uZW50cy9saW5rLXByb2dyYW0vcHJvZ3JhbS1pbnRlZ3JhdGlvbi1pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNlbGVjdGVkVmFsdWVze1xyXG4gICAgcHJvZ3JhbTogYW55LFxyXG4gICAgY2F0ZWdvcmllczogIHt9W11cclxuICAgIHJlc3BvbnNpYmlsaXRpZXM6IHt9W11cclxufVxyXG5leHBvcnQgaW50ZXJmYWNlIFNlbGVjdGVkSWRze1xyXG4gICAgY2F0ZWdvcmllczogbnVtYmVyW10sXHJcbiAgICByZXNwb25zaWJpbGl0aWVzOiBudW1iZXJbXSxcclxufSJdfQ==

package/esm2022/lib/sharedComponents/link-program/restapi.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable, Optional } from '@angular/core';
+import { HttpHeaders, } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { of } from 'rxjs';
+import { retry, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../workflow-services/auth.service";
+import * as i3 from "../../configurations";
+export class RestApiService {
+    constructor(httpClient, authService, config) {
+        this.httpClient = httpClient;
+        this.authService = authService;
+        if (config) {
+            this.env = config.envConfig;
+        }
+    }
+    /**
+     * Interceptor where will intercept any thing has to be intercept in header like token or business cycle
+     * anything related to common which needs to pass in each api
+     */
+    intercept(request, next) {
+        return next.handle(request);
+    }
+    /**
+     * This Handler contains REST_URL which is used to host the server.
+     */
+    /**
+     * This displays the error message when the server is not taking the data.
+     * There are Two types errors.
+     * Client-side errors.
+     * Server-side errors
+     */
+    handleError(error) {
+        let errorMessage = 'Unknown error!';
+        if (error.error instanceof ErrorEvent) {
+            // Client-side errors
+            errorMessage = `Error: ${error.error.message}`;
+        }
+        else {
+            // Server-side errors
+            if (error.status === 401) {
+                // auto logout if 401 response returned from api
+                localStorage.clear();
+                location.reload();
+            }
+            errorMessage = `Error Code: ${error.status}\nMessage: ${error.message}`;
+        }
+        return throwError(errorMessage);
+    }
+    //business cycle code added
+    getBusinessCycle() {
+        const localStorageData = localStorage.getItem('businessCycle') ?? '';
+        const businessCycle = JSON.parse(localStorageData)?.selectedCycle;
+        let currentBusinessCycle = {
+            selected_cycle: businessCycle?.start_date + '-' + businessCycle?.end_date,
+            start_date: businessCycle?.start_date,
+            end_date: businessCycle?.end_date,
+            selected_cycle_arr: businessCycle?.selected_cycle_arr,
+        };
+        return currentBusinessCycle;
+    }
+    apiDelegate(req, additionalUrl) {
+        let httpOptions = {};
+        let headers = new HttpHeaders();
+        httpOptions.headers = headers.append('token', this.authService.getAuthorizationToken());
+        if (req?.params) {
+            httpOptions.params = req.params;
+        }
+        if (req?.payloadObject) {
+            httpOptions.headers = httpOptions.headers.append('payload-object', JSON.stringify(req.payloadObject));
+        }
+        if (req?.businessCycle) {
+            httpOptions.headers = httpOptions.headers.append('x-business-cycle', JSON.stringify(req.businessCycle));
+        }
+        const url = this.env[req?.action];
+        switch (req.method.toLowerCase()) {
+            case 'get':
+                return this.httpClient
+                    .get(url + additionalUrl, httpOptions)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'post':
+                return this.httpClient.post(url + additionalUrl, req.data, httpOptions);
+            case 'put':
+                return this.httpClient
+                    .put(url + additionalUrl, req.data)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'patch':
+                return this.httpClient
+                    .patch(url + additionalUrl, req.data)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'delete':
+                return this.httpClient
+                    .delete(url + additionalUrl, httpOptions)
+                    .pipe(retry(2), catchError(this.handleError));
+            default:
+                return of('invalid req');
+        }
+    }
+    // don't use this
+    apiTestDelegate(req) {
+        let httpOptions = {};
+        let headers = new HttpHeaders();
+        httpOptions.headers = headers.append('token', this.authService.getAuthorizationToken());
+        if (req?.params) {
+            httpOptions.params = req.params;
+        }
+        if (req?.payloadObject) {
+            httpOptions.headers = httpOptions.headers.append('payload-object', JSON.stringify(req.payloadObject));
+        }
+        if (req?.businessCycle) {
+            httpOptions.headers = httpOptions.headers.append('x-business-cycle', JSON.stringify(req.businessCycle));
+        }
+        const url = 'http://localhost:3000/dev';
+        switch (req.method.toLowerCase()) {
+            case 'get':
+                return this.httpClient
+                    .get(url + req.action, httpOptions)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'post':
+                return this.httpClient.post(url + req.action, req.data, httpOptions);
+            case 'put':
+                return this.httpClient
+                    .put(url + req.action, req.data)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'patch':
+                return this.httpClient
+                    .patch(url + req.action, req.data)
+                    .pipe(retry(2), catchError(this.handleError));
+            case 'delete':
+                return this.httpClient
+                    .delete(url + req.action, httpOptions)
+                    .pipe(retry(2), catchError(this.handleError));
+            default:
+                return of('invalid req');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestApiService, deps: [{ token: i1.HttpClient }, { token: i2.AuthService }, { token: i3.Configurations, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.AuthService }, { type: i3.Configurations, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restapi.service.js","sourceRoot":"","sources":["../../../../../../projects/vx-workflow-engine/src/lib/sharedComponents/link-program/restapi.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\r\nimport {\r\n  HttpClient,\r\n  HttpErrorResponse,\r\n  HttpInterceptor,\r\n  HttpRequest,\r\n  HttpHandler,\r\n  HttpEvent,\r\n  HttpHeaders,\r\n  HttpParams,\r\n} from '@angular/common/http';\r\nimport { throwError, Observable, Subject } from 'rxjs';\r\nimport { of } from 'rxjs';\r\nimport { retry, catchError } from 'rxjs/operators';\r\nimport { AuthService } from '../../workflow-services/auth.service';\r\nimport { Configurations } from '../../configurations';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RestApiService implements HttpInterceptor {\r\n  env!: any;\r\n  constructor(\r\n    private httpClient: HttpClient,\r\n    private authService: AuthService,\r\n    @Optional() config?: Configurations\r\n  ) {\r\n    if (config) {\r\n      this.env = config.envConfig;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Interceptor where will intercept any thing has to be intercept in header like token or business cycle\r\n   * anything related to common which needs to pass in each api\r\n   */\r\n  intercept(\r\n    request: HttpRequest<any>,\r\n    next: HttpHandler\r\n  ): Observable<HttpEvent<any>> {\r\n    return next.handle(request);\r\n  }\r\n\r\n  /**\r\n   * This Handler contains REST_URL which is used to host the server.\r\n   */\r\n\r\n  /**\r\n   * This displays the error message when the server is not taking the data.\r\n   * There are Two types errors.\r\n   * Client-side errors.\r\n   * Server-side errors\r\n   */\r\n  handleError(error: HttpErrorResponse) {\r\n    let errorMessage = 'Unknown error!';\r\n    if (error.error instanceof ErrorEvent) {\r\n      // Client-side errors\r\n      errorMessage = `Error: ${error.error.message}`;\r\n    } else {\r\n      // Server-side errors\r\n      if (error.status === 401) {\r\n        // auto logout if 401 response returned from api\r\n        localStorage.clear();\r\n        location.reload();\r\n      }\r\n      errorMessage = `Error Code: ${error.status}\\nMessage: ${error.message}`;\r\n    }\r\n    return throwError(errorMessage);\r\n  }\r\n\r\n  //business cycle code added\r\n  getBusinessCycle() {\r\n    const localStorageData = localStorage.getItem('businessCycle') ?? '';\r\n    const businessCycle = JSON.parse(localStorageData)?.selectedCycle;\r\n\r\n    let currentBusinessCycle = {\r\n      selected_cycle: businessCycle?.start_date + '-' + businessCycle?.end_date,\r\n      start_date: businessCycle?.start_date,\r\n      end_date: businessCycle?.end_date,\r\n      selected_cycle_arr: businessCycle?.selected_cycle_arr,\r\n    };\r\n    return currentBusinessCycle;\r\n  }\r\n\r\n  apiDelegate(req: any, additionalUrl?: string) {\r\n    let httpOptions: any = {};\r\n    let headers = new HttpHeaders();\r\n    httpOptions.headers = headers.append(\r\n      'token',\r\n      this.authService.getAuthorizationToken()\r\n    );\r\n    if (req?.params) {\r\n      httpOptions.params = req.params;\r\n    }\r\n    if (req?.payloadObject) {\r\n      httpOptions.headers = httpOptions.headers.append(\r\n        'payload-object',\r\n        JSON.stringify(req.payloadObject)\r\n      );\r\n    }\r\n    if (req?.businessCycle) {\r\n      httpOptions.headers = httpOptions.headers.append(\r\n        'x-business-cycle',\r\n        JSON.stringify(req.businessCycle)\r\n      );\r\n    }\r\n\r\n    const url = this.env[req?.action];\r\n    switch (req.method.toLowerCase()) {\r\n      case 'get':\r\n        return this.httpClient\r\n          .get(url + additionalUrl, httpOptions)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'post':\r\n        return this.httpClient.post(url + additionalUrl, req.data, httpOptions);\r\n      case 'put':\r\n        return this.httpClient\r\n          .put(url + additionalUrl, req.data)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'patch':\r\n        return this.httpClient\r\n          .patch(url + additionalUrl, req.data)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'delete':\r\n        return this.httpClient\r\n          .delete(url + additionalUrl, httpOptions)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      default:\r\n        return of('invalid req');\r\n    }\r\n  }\r\n\r\n  // don't use this\r\n  apiTestDelegate(req: any) {\r\n    let httpOptions: any = {};\r\n    let headers = new HttpHeaders();\r\n    httpOptions.headers = headers.append(\r\n      'token',\r\n      this.authService.getAuthorizationToken()\r\n    );\r\n    if (req?.params) {\r\n      httpOptions.params = req.params;\r\n    }\r\n    if (req?.payloadObject) {\r\n      httpOptions.headers = httpOptions.headers.append(\r\n        'payload-object',\r\n        JSON.stringify(req.payloadObject)\r\n      );\r\n    }\r\n    if (req?.businessCycle) {\r\n      httpOptions.headers = httpOptions.headers.append(\r\n        'x-business-cycle',\r\n        JSON.stringify(req.businessCycle)\r\n      );\r\n    }\r\n    const url = 'http://localhost:3000/dev';\r\n    switch (req.method.toLowerCase()) {\r\n      case 'get':\r\n        return this.httpClient\r\n          .get(url + req.action, httpOptions)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'post':\r\n        return this.httpClient.post(url + req.action, req.data, httpOptions);\r\n      case 'put':\r\n        return this.httpClient\r\n          .put(url + req.action, req.data)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'patch':\r\n        return this.httpClient\r\n          .patch(url + req.action, req.data)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      case 'delete':\r\n        return this.httpClient\r\n          .delete(url + req.action, httpOptions)\r\n          .pipe(retry(2), catchError(this.handleError));\r\n      default:\r\n        return of('invalid req');\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/sharedComponents/link-program/tooltip-validation.pipe.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipValidationPipe {
+    transform(value, program) {
+        value = value?.toString();
+        const index = value?.indexOf('<br>');
+        if (index == -1) {
+            let newVal = value?.replaceAll(/<\/?span[^>]*>/g, "");
+            newVal = newVal?.replaceAll("<", "&lt;");
+            if (program?.name?.length) {
+                newVal = newVal + `<span class='small-text'>WITHIN: ${program?.name?.join(' < ')}</span>`;
+            }
+            return newVal;
+        }
+        else {
+            return value;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipValidationPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TooltipValidationPipe, name: "tooltipValidation" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipValidationPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'tooltipValidation'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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