vcomply-workflow-engine 2.0.4 → 2.0.167

package/projects/vx-workflow-engine/src/lib/pipes/data-type.pipe.ts

@@ -0,0 +1,12 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'dataType'
+})
+export class DataTypePipe implements PipeTransform {
+
+  transform(value: any, ...args: unknown[]): any {
+    return typeof value;
+  }
+
+}

package/projects/vx-workflow-engine/src/lib/pipes/dom-sanitizer.pipe.spec.ts

@@ -0,0 +1,8 @@
+import { DomSanitizerPipe } from './dom-sanitizer.pipe';
+
+describe('DomSanitizerPipe', () => {
+  it('create an instance', () => {
+    const pipe = new DomSanitizerPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/pipes/dom-sanitizer.pipe.ts

@@ -0,0 +1,17 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+
+@Pipe({
+  name: 'domSanitizer',
+})
+export class DomSanitizerPipe implements PipeTransform {
+  constructor(private sanitizer: DomSanitizer) {}
+
+  transform(htmlString: string): any {
+    if (!htmlString) {
+      return htmlString;
+    }
+    const cleanString = htmlString.replace(/<[^>]*>/g, '');
+    return cleanString;
+  }
+}

package/projects/vx-workflow-engine/src/lib/pipes/filter.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'filter',
+})
+export class FilterPipe implements PipeTransform {
+  transform(value: any, indentfier: any, excludelist: any): any {
+    console.log(value, indentfier, excludelist);
+    const key = indentfier;
+    const list = excludelist;
+    if (key && list?.length) {
+      const itemIdsArray = list.map(list[key]);
+      return value.filter((e: any) => !itemIdsArray.includes(e[key]));
+    } else {
+      return value;
+    }
+  }
+}

package/projects/vx-workflow-engine/src/lib/pipes/list-mapper.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'listMapper',
+  pure: false
+})
+export class ListMapperPipe implements PipeTransform {
+
+  transform(value: any, ...args: any[]): unknown {
+
+    const selected = value;
+    const list = args[0];
+    const key = args[1];
+    const x = list.filter((el: any) => selected.includes(el[key]));
+    return x;
+  }
+
+}

package/projects/vx-workflow-engine/src/lib/pipes/pipes.module.ts

@@ -0,0 +1,38 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DataTypePipe } from './data-type.pipe';
+import { FilterPipe } from './filter.pipe';
+import { ListMapperPipe } from './list-mapper.pipe';
+import { SearchPipe } from './search.pipe';
+import { SpaceBreakerPipe } from './space-breaker.pipe';
+import { UncategorizedFilterPipe } from './uncategorized-filter.pipe';
+import { UserFilterPipe } from './user-filter.pipe';
+import { TooltipMessagePipe } from '../workflow-program/create-program-ui/define-framework-listing/pipes/tooltip-message.pipe';
+import { DomSanitizerPipe } from './dom-sanitizer.pipe';
+
+@NgModule({
+  declarations: [
+    DataTypePipe,
+    FilterPipe,
+    ListMapperPipe,
+    SearchPipe,
+    SpaceBreakerPipe,
+    UncategorizedFilterPipe,
+    UserFilterPipe,
+    TooltipMessagePipe,
+    DomSanitizerPipe,
+  ],
+  imports: [CommonModule],
+  exports: [
+    DataTypePipe,
+    FilterPipe,
+    ListMapperPipe,
+    SearchPipe,
+    SpaceBreakerPipe,
+    UncategorizedFilterPipe,
+    UserFilterPipe,
+    TooltipMessagePipe,
+    DomSanitizerPipe,
+  ],
+})
+export class PipesModule {}

package/projects/vx-workflow-engine/src/lib/pipes/search.pipe.ts

@@ -0,0 +1,63 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'search'
+})
+export class SearchPipe implements PipeTransform {
+  transform(items: any[], ...args: any[]): any[] {
+    let searchText = args[0];
+    const searchKey = args[1];
+    if (!items) {
+      return [];
+    }
+    if (!searchText) {
+      return items;
+    }
+    searchText = searchText?.toLowerCase();
+    if(items?.length){
+    return items.filter((it: any) => {
+      if(!searchKey){
+         return JSON.stringify(it)?.toLowerCase()?.includes(searchText);
+      }
+      else if(searchKey){
+        // return empIds.indexOf(itm.empid) > -1;
+
+        return it[searchKey]?.toString()?.toLowerCase()?.indexOf(searchText) > -1;
+        //return it[searchKey].toLowerCase().includes(searchText);
+      }
+
+    });
+  }else{
+     return [];
+  }
+  }
+}
+// export class FilterPipe implements PipeTransform {
+//   transform(items: any[], ...args: any[]): any[] {
+//     let searchText = args[0];
+//     const searchKey = args[1];
+//     if (!items) {
+//       return [];
+//     }
+//     if (!searchText) {
+//       return items;
+//     }
+//     searchText = searchText.toLowerCase();
+//     if(items?.length){
+//     return items.filter((it: any) => {
+//       if(!searchKey){
+//          return JSON.stringify(it).toLowerCase().includes(searchText);
+//       }
+//       else if(searchKey){
+//         // return empIds.indexOf(itm.empid) > -1;
+//         console.log("sda",it[searchKey].toLowerCase().indexOf(searchText) > -1)
+//         return it[searchKey].toLowerCase().indexOf(searchText) > -1;
+//         //return it[searchKey].toLowerCase().includes(searchText);
+//       }
+
+//     });
+//   }else{
+//      return [];
+//   }
+//   }
+// }

package/projects/vx-workflow-engine/src/lib/pipes/space-breaker.pipe.spec.ts

@@ -0,0 +1,8 @@
+import { SpaceBreakerPipe } from './space-breaker.pipe';
+
+describe('SpaceBreakerPipe', () => {
+  it('create an instance', () => {
+    const pipe = new SpaceBreakerPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/pipes/space-breaker.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'spaceBreaker'
+})
+export class SpaceBreakerPipe implements PipeTransform {
+
+  transform(value: any, ...args: any[]): any {
+
+    if(value.length){
+      return value.replace(/&nbsp;/g, '').replace(/\<br\s*[\/]?>/gi, '').trim();
+    }else{
+      return value;
+    }
+
+  }
+
+}

package/projects/vx-workflow-engine/src/lib/pipes/uncategorized-filter.pipe.spec.ts

@@ -0,0 +1,8 @@
+import { UncategorizedFilterPipe } from './uncategorized-filter.pipe';
+
+describe('UncategorizedFilterPipe', () => {
+  it('create an instance', () => {
+    const pipe = new UncategorizedFilterPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/pipes/uncategorized-filter.pipe.ts

@@ -0,0 +1,16 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'uncategorizedFilter'
+})
+export class UncategorizedFilterPipe implements PipeTransform {
+
+  transform(value: any, ...args: any[]): any {
+    if(value){
+     return value.filter((category:any) => category?.category_name != 'uncategorized') 
+    }else{
+      return value;
+    }
+  }
+
+}

package/projects/vx-workflow-engine/src/lib/pipes/user-filter.pipe.ts

@@ -0,0 +1,28 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { cloneDeep } from 'lodash';
+
+@Pipe({
+  name: 'userFilter'
+})
+export class UserFilterPipe implements PipeTransform {
+
+  transform(value: any, ...args: any[]): any {
+    const key = args[0];
+    const list = cloneDeep(args[1]);
+    list.push(args[2]);
+    if (key && list.length > 0){
+           const itemIdsArray = list.map( (obj: any) => {
+           return obj[key];
+         });
+
+           return value.filter((el: any) =>
+           {
+             return !itemIdsArray.includes(el[key]);
+           });
+        }
+        else{
+          return value;
+        }
+  }
+
+}

package/projects/vx-workflow-engine/src/lib/services/auth.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { AuthService } from './auth.service';
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(AuthService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/services/auth.service.ts

@@ -0,0 +1,174 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, catchError, map, Observable, of, pluck, retry, shareReplay } from 'rxjs';
+import { AuthorizerService } from '@vcomply/authorizer';
+import { Configurations } from '../configurations';
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthService {
+  public subscriptionDetails: BehaviorSubject<any[]> = new BehaviorSubject<any[]>([]);
+  public userDetails: BehaviorSubject<any> = new BehaviorSubject<any>({});
+  env: any;
+  permissions:any =[];
+
+
+  //VIEW_ASSESSMENT_LIBRARY
+  //MANAGE_ASSESSMENT_LIBRARY
+  //VIEW_ASSESSMENTS
+  //VIEW_ASSESSMENTS
+
+  roleBasedPermission !:any;
+
+  constructor(private http: HttpClient, private authorizer: AuthorizerService, @Optional() config?: Configurations) {
+    this.getSubscriptionDetails().subscribe();
+    this.env = config?.envConfig;
+  }
+  setPermission(){
+    const assessmentPermission = this.roleBasedPermission.filter((ele:any) => ele.moduleName === 'assessment')
+    if(assessmentPermission?.length > 0){
+      const permission = assessmentPermission[0];
+      const allowedFlows:any = []
+      permission.subModule.forEach((ele:any)=>{
+
+        ele.permissions.forEach((subModule:any)=>{
+
+
+          switch(subModule?.code){
+            case 'AALVAL' : {
+
+
+                             if(subModule?.defaultPermission==1 || subModule?.enable==1){allowedFlows.push('VIEW_ASSESSMENT_LIBRARY')};
+                             break;
+                            }
+            case 'AALMAL' : {
+                            if (subModule?.defaultPermission || subModule?.enable){ allowedFlows.push('MANAGE_ASSESSMENT_LIBRARY')};
+                             break;
+                            }
+            case 'AAVA' : {
+                              if(subModule?.defaultPermission || subModule?.enable){ allowedFlows.push('VIEW_ASSESSMENTS')};
+                              break;
+                             }
+            case 'AAMA'  :{
+                            if(subModule?.defaultPermission || subModule?.enable){ allowedFlows.push('MANAGE_ASSESSMENTS')};
+                            break;
+                           }
+
+          }
+        })
+      })
+
+      this.permissions = allowedFlows;
+    }
+  }
+
+  /**
+  * Returns weather the user data loaded or not
+  * @returns
+  */
+  startApp() {
+    return new Promise((resolve, reject) => {
+      this.getUser().subscribe((res: any) => {
+        resolve(true);
+      });
+    });
+  }
+
+  /**
+  * Gets user details
+  * @returns
+  */
+  getUser() {
+    return this.http.get(this.env.organizationGet + 'memberFindbyId&id=' + this.authorizer.getMemberId() ?? '')
+      .pipe(map((res:any) => {
+        this.userDetails.next(res as any);
+
+        this.roleBasedPermission = res?.roleActions ;
+        this.setPermission();
+      }), shareReplay(1)
+      ).pipe(retry(2));
+  }
+
+  getSubscriptionDetails() {
+    return this.http
+      .get(this.env.organizationGet + 'subscriptionList').pipe(map((res: any) => {
+        this.subscriptionDetails.next(res as any);
+
+      }), catchError((err) => of(err))).pipe(retry(2));
+  }
+
+
+  getUserRole(): 'KEY_ADMIN' | 'ADMIN' | 'MANAGER' | 'EXECUTIVE' {
+    if (this.authorizer.isKeyAdmin()) {
+      return 'KEY_ADMIN';
+    } else if (this.authorizer.isAdmin()) {
+      return 'ADMIN';
+    } else if (this.authorizer.isManager()) {
+      return 'MANAGER';
+    } else {
+      return 'EXECUTIVE';
+    }
+  }
+  logout(){
+    this.authorizer.logout()
+  }
+  convertUtcToLocalDateTime(timestamp: string | number) {
+    if (typeof timestamp !== 'string') {
+      let TimeZone = this.authorizer.getUserTimezone()??'';
+      const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+      const dayName = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+      if (TimeZone === '' || parseInt(timestamp.toString(), 10) <= 0) {
+        return '0';
+      } else {
+        const UTC_TIME = new Intl.DateTimeFormat('en', {
+          timeZone: TimeZone,
+          hour: 'numeric',
+          minute: 'numeric',
+        });
+        const GET_TIME = UTC_TIME.format(new Date(timestamp * 1000));
+
+        const UTC_DATE = new Intl.DateTimeFormat('en', {
+          timeZone: TimeZone,
+        });
+
+        const MY_DATE = UTC_DATE.format(new Date(timestamp * 1000));
+        const date = new Date(MY_DATE);
+        const DAY_NAME = dayName[date.getDay()];
+        let day = date.getDate().toString();
+        day = day.length === 1 ? '0' + day : day;
+        const monthIndex = date.getMonth();
+        const year = date.getFullYear();
+
+        const GET_DATE = day + '-' + monthNames[monthIndex] + '-' + year;
+
+        // const DATE_TIME = GET_DATE + ' ' + GET_TIME ;
+        return GET_DATE;
+      }
+    }
+    return '';
+  }
+  getNotificationDetails(): Observable<number> {
+    return this.http.get<number>(this.env.complianceGet + 'complianceReport/TotalResponsibilityQueue').pipe(retry(2));
+  }
+
+   userId(){
+    return this.authorizer.getUserId()??'';
+   }
+
+   getBussinessCycle() {
+    return this.http.get(this.env.organizationGet + 'orgDetails&id=' + this.getOrgId()).pipe(retry(2));
+  }
+
+  getOrgId(){
+    const userInfo  = this.authorizer.getUser();
+    return userInfo?.organisation_id ? userInfo.organisation_id :null;
+  }
+
+  resetBusinessCycle() {
+    localStorage.removeItem('businessCycle');
+  }
+
+
+
+
+}

package/projects/vx-workflow-engine/src/lib/services/bulk-upload.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BulkUploadService } from './bulk-upload.service';
+
+describe('BulkUploadService', () => {
+  let service: BulkUploadService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(BulkUploadService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/services/bulk-upload.service.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { cloneDeep } from 'lodash-es';
+import * as XLSX from 'xlsx';
+type AOA = any[][];
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BulkUploadService {
+
+  constructor() { }
+
+  hasDataInList(data: any, dataStartIndex: number) {
+    const listData = XLSX.utils.sheet_to_json(data, {
+      header: 1, raw: false,
+    }) as AOA;
+
+    let finalData = listData.slice(dataStartIndex);
+    return this.checkEmptyFile(finalData);
+  }
+
+  checkEmptyFile(data: any) {
+    let isEmpty = false;
+    data = data.filter((dataElement: any) => dataElement.length > 0);
+    if (data.length < 1) {
+      isEmpty = true;
+    }
+    return isEmpty;
+  }
+
+  checkCorrectFile(data: any, headerIndex: number): boolean {
+    const listData = XLSX.utils.sheet_to_json(data, {
+      header: 1, raw: false,
+    }) as AOA;
+    const header = cloneDeep(listData[headerIndex]);
+    if(headerIndex === 2) {
+      return header[0] === 'Responsibility Name*' ? true: false;
+    } else if(headerIndex === 0) {
+      return header[0] === 'Enter Responsibility Name*' ? true: false;
+    } 
+    return false;
+  }
+}

package/projects/vx-workflow-engine/src/lib/services/event-bridge.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { EventBridgeService } from './event-bridge.service';
+
+describe('EventBridgeService', () => {
+  let service: EventBridgeService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(EventBridgeService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/services/event-bridge.service.ts

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, Subject, take } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EventBridgeService {
+  
+  constructor() { }
+  //when true submenu will be opened if false submenu will be closed;
+  private subMenuToggle: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  subMenuStatus$: Observable<boolean> = this.subMenuToggle.asObservable();
+
+
+  //when false sub-menu will not overlap the current page, if true submenu will overlap 
+  private subMenuElevated: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
+  subMenuOverlayed$: Observable<boolean> = this.subMenuElevated.asObservable();
+
+  openSubMenu(){
+    this.subMenuToggle.next(true);
+  }
+  closeSubMenu(){
+    this.subMenuToggle.next(false);
+  }
+  // Bridge for search
+  private search: Subject<string> = new Subject<string>();
+  executeSearch$: Observable<string> = this.search.asObservable();
+
+  executeSearch(term:string){
+    this.search.next(term);
+  }
+
+    //when true popup is enabled for user account
+    private userAccount: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+    userAccountStatus$: Observable<boolean> = this.userAccount.asObservable();
+
+    toggleUserAccount(){
+      this.userAccountStatus$.pipe(take(1)).subscribe({
+        next:(res:boolean)=>{ this.userAccount.next(!res)}
+      })
+    }
+
+    setSubMenuOverlay(evt:boolean){
+      this.subMenuElevated.next(evt)
+    }
+
+}

package/projects/vx-workflow-engine/src/lib/services/permission.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { PermissionService } from './permission.service';
+
+describe('PermissionService', () => {
+  let service: PermissionService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(PermissionService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/vx-workflow-engine/src/lib/services/permission.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PermissionService {
+
+  constructor() { }
+  
+  // activate permissions
+  permissions:any =['VIEW_ASSESSMENT_LIBRARY','MANAGE_ASSESSMENT_LIBRARY','VIEW_ASSESSMENTS','MANAGE_ASSESSMENTS'];
+
+
+  //VIEW_ASSESSMENT_LIBRARY
+  //MANAGE_ASSESSMENT_LIBRARY
+  //VIEW_ASSESSMENTS
+  //VIEW_ASSESSMENTS
+
+  roleBasedPermission !:any;
+  setPermission(){
+    const assessmentPermission = this.roleBasedPermission.filter((ele:any) => ele.moduleName === 'assessment')
+  }
+}