vcomply-workflow-engine 2.0.4 → 2.0.167

package/projects/vx-workflow-engine/src/lib/workflow-policy/workflow-policy.component.ts

@@ -0,0 +1,2217 @@
+import {
+  ChangeDetectorRef,
+  Component,
+  EventEmitter,
+  Input,
+  OnInit,
+  Output,
+  ViewChild,
+} from '@angular/core';
+import { cloneDeep, uniqBy } from 'lodash';
+import { DatePickerComponent } from 'ng2-date-picker';
+import { EditorConfig } from 'vcomply-editor';
+import { ConfirmationAlert } from '../interfaces/confirmation-alert';
+import { SnackBarService } from '../ui-kit/snack-bar/snack-bar.service';
+import { PolicyForm } from '../workflow-interfaces/create-policy-form';
+import { AuthService } from '../workflow-services/auth.service';
+import { PolicyService } from '../workflow-services/policy.service';
+import { ResponsibilityService } from '../workflow-services/responsibility.service';
+import { UiKitService } from '../workflow-services/ui-kit.service';
+import { PlatformLocation } from '@angular/common';
+import moment from 'moment/moment';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FrequencyService } from '../sharedComponents/frequency/frequency.service';
+import { FormatAndEvidenceComponent } from '../sharedComponents/format-and-evidence/format-and-evidence.component';
+import { RestApiService } from '../sharedComponents/link-program/restapi.service';
+
+@Component({
+  selector: 'app-workflow-policy',
+  templateUrl: './workflow-policy.component.html',
+  styleUrls: ['./workflow-policy.component.less', '../forms.less'],
+})
+export class WorkflowPolicyComponent implements OnInit {
+  @Output() pickerChanged = new EventEmitter();
+  @Input() mode = 'CREATE';
+  @Input() policyId = '';
+  @Input() feature: any;
+  @Output() showConfirmationAlert = new EventEmitter();
+  @ViewChild('datePicker') datePicker!: DatePickerComponent;
+  @Output() populateOption = new EventEmitter();
+  @Output() disconnectRefresh = new EventEmitter();
+  @Output() shiftToEditMode = new EventEmitter();
+  @Input() convertFileData: any = {};
+  @Input() selectedCategory = '';
+  @Input() isSendForAttestation: boolean = false;
+
+  @ViewChild('formatEvidence') formatEvidence!: FormatAndEvidenceComponent;
+
+  description: EditorConfig = {
+    mode: 'prime',
+    colorPalette: true,
+    link: true,
+    placeholder: 'Add a description for this policy.',
+  };
+  workflowType = 'SEQUENTIAL';
+  scrollToBottom = false;
+  navigateToDocumentsSection = false;
+
+  activeSelector = '';
+  rcList: any = [];
+  usersList: any = [];
+  allApprovers: any = [];
+  allReviewers: any = [];
+  assigneesList: any = [];
+  ownerlist: any = [];
+  reviewersList: any = [];
+  overseersList: any = [];
+  rcListLoaded = false;
+  usersListLoaded = false;
+  categoryList: any = [];
+  groupsList: any[] = [];
+  workFlowList: any[] = [];
+  approverWorkFlowList: any[] = [];
+  submitted = false;
+  ccEmailObjIds: any[] = [];
+  ccFailGroupObjIds: any[] = [];
+  usersAccessList: any[] = [];
+  usersAccessListIds: any[] = [];
+  groupsAccessListIds: any[] = [];
+  groupsAccessList: any[] = [];
+
+  loader = false;
+  categoriesListLoaded = false;
+  groupsListLoaded = false;
+  categoryConfig = {
+    panelTitle: 'Select Policy Category',
+    floatingTextSingular: 'Policy Category Selected',
+    floatingTextPlural: 'Policy Categories Selected',
+    searchPlaceholder: 'Search Policy Category',
+    searchEnabled: true,
+    selectAllEnabled: true,
+    workflow: 'policy',
+  };
+  approvalWorkflowConfig = {
+    panelTitle: 'Select user(s)',
+    floatingTextSingular: 'User selected',
+    floatingTextPlural: 'Users selected',
+    searchPlaceholder: 'Search User',
+    searchEnabled: true,
+    selectAllEnabled: true,
+  };
+
+  addMoreLevels = false;
+  approversListIndex = 0;
+  workflowList = ['SEQUENTIAL', 'ROUND-ROBIN', 'ANY ONE'];
+  datePickerOverlay = false;
+  dateConfig = {
+    disableKeypress: true,
+    format: 'DD MMM YYYY',
+    unSelectOnClick: true,
+    openOnClick: false,
+    openOnFocus: false,
+  };
+  frequencyDetails = {
+    pattern: '',
+    notificationPending: 0,
+    dateOfModified: 0,
+    deactivationValue: 0,
+    selectedReport: 0,
+    lifecycle: '0000-00-00~~0',
+    startDate: Math.floor(new Date().getTime() / 1000),
+    startOnTheDay: Math.floor(new Date().getTime() / 1000),
+    window: 0,
+    failed: 0,
+    time: '11:59 pm',
+    failedTime: '',
+    continuous_failed_days: 0,
+  };
+  reviewerFrequencyDetails = {
+    pattern: '',
+    notificationPending: 0,
+    dateOfModified: 0,
+    deactivationValue: 0,
+    selectedReport: 0,
+    lifecycle: '0000-00-00~~0',
+    startDate: Math.floor(new Date().getTime() / 1000),
+    startOnTheDay: Math.floor(new Date().getTime() / 1000),
+    window: 0,
+    failed: 0,
+    time: '11:59 pm',
+    failedTime: '',
+    continuous_failed_days: 3,
+  };
+  frequencyPlaceholder = 'What is the attestation schedule for this policy?';
+  reviewerFrequencyPlaceholder = 'When does this policy need to be reviewed?';
+
+  sideSelectorElements = [
+    'approvalWorkflow',
+    'assignees',
+    'approvers',
+    'reviewer',
+    'ccEmail',
+    'ccFail',
+    'rc',
+    'category',
+    'frequency',
+    'reviewerFrequency',
+    'checkpoints',
+    'linkProgram',
+    'isAssessment',
+    'owners',
+    'policyAccess',
+  ];
+  riskClassification = [
+    { name: 'LOW', value: 1, class: 'low' },
+    { name: 'LOW-Medium', value: 2, class: 'low-med' },
+    { name: 'Medium-High', value: 3, class: 'med-high' },
+    { name: 'High', value: 4, class: 'high' },
+  ];
+  showRiskClassification = true;
+  showCreateDocuments = false;
+  organization_id = '';
+  member_obj_id = '';
+  memberId = 0;
+  userInfo!: any;
+
+  policyApprovalFlag = 0;
+  baseURL = '';
+  groupEnabled: any = true;
+  overseerGroupsList: any[] = [];
+  enableApprovalWorkflow: boolean = false;
+  isVersionValid: boolean = true;
+  selectedLinkProgram: any = {};
+  versionErrorMessage: string =
+    'You have entered an incorrect format. The version field can either include numbers, alphabets, hyphen or dots.';
+  selectedWorkflow: any[] = [];
+  editApprovalWorkflow!: any;
+  approvalWorkflowIds: any[] = [];
+  defaultEditApprovers: any = {};
+  createApprovalClick: boolean = false;
+  editWorkflowLevel = {};
+  noWorkflowSelected: boolean = false;
+
+  constructor(
+    private policyService: PolicyService,
+    private snackBar: SnackBarService,
+    private uiKitService: UiKitService,
+    private authService: AuthService,
+    private responsibilityService: ResponsibilityService,
+    private router: Router,
+    private route: ActivatedRoute,
+    private frequencyService: FrequencyService,
+    platformLocation: PlatformLocation,
+    private changeRef: ChangeDetectorRef,
+    private restApiService: RestApiService
+  ) {
+    this.baseURL = (platformLocation as any).location.origin;
+    if (this.baseURL == 'http://localhost:4200') {
+      this.baseURL = 'https://dev.v-comply.com';
+    }
+  }
+  policyForm: PolicyForm = {
+    policyName: '',
+    policyNotes: '',
+    selectedCategories: [],
+    selectedApprovers: [],
+    selectedAssignees: [], //doubt in name
+    selectedGroupAssignee: [],
+    selectedReviewers: [],
+
+    selectedRCs: [],
+    CCFailEmail: [],
+    CCFailEmailGroup: [],
+    CCEmail: [],
+    CCGroupEmail: [],
+    availableOnPortal: false,
+    acceptSuggestions: false,
+    requiresSignatureForAttestation: false,
+    riskRating: 1,
+    associatedDocuments: {
+      formatFiles: [],
+    },
+    policyDueDate: moment(),
+    customTags: [],
+    checkpointDetails: [],
+    totalQuestion: 0,
+    passingMarks: 0,
+    documentsAndLinks: {
+      formatFiles: [],
+      formatLinks: [],
+    },
+    addResponsibilityCenters: false,
+    addReviewers: false,
+    addCheckpoints: false,
+    addOverseers: false,
+    addAssociatedDocuments: false,
+    addVersion: false,
+    addLinkAssessment: false,
+    addLinkProgram: false,
+
+    failed_time: '',
+    frequency_details: '',
+    frequency_text: '',
+    mark_failed_after: 0,
+    remind_days_before_due_date: 0,
+
+    reviewFailedAfter: 0,
+    reviewFailedTime: '',
+    review_frequency_details: '',
+    review_frequency_type: '',
+    review_remind_days_before_due_date: 0,
+    review: false,
+    linkProgram: {},
+    programSelectedValues: {},
+    assignee_start_date: '', //Thu Feb 22 2024
+    reviewer_start_date: '', //Thu Feb 22 2024
+    policy_version: '', // it will accept matches alphabets, hyphens (-), dots (.), and numeric values only and should be smaller or equal to 6 characters
+    assessment: [],
+    policy_owners: [],
+    policy_group_owners: [],
+    businessCycle: {},
+    policy_id: 0,
+    policy_access_type: 0,
+    policy_access_owners: [],
+    policy_access_groups: [],
+  };
+  ngOnInit(): void {
+    this.groupEnabled =
+      this.feature?.isFeatureEnabled('ff_policy_groups') || true;
+    this.getRCList();
+    this.getUsersList();
+    this.getCategoriesList();
+    this.getGroupsList();
+    this.overseerGroupList();
+    this.checkWhetherAllListsLoaded();
+    this.loader = true;
+    this.authService.getOrganizationDetails().subscribe((res: any) => {
+      if (!res.enable_riskclass) {
+        this.showRiskClassification = false;
+      }
+      if (res._id) {
+        this.organization_id = res._id;
+      }
+    });
+    this.member_obj_id = this.authService.getUserDetails()._id;
+    this.userInfo = this.authService.getUserDetails().user;
+    this.memberId = this.authService.getMemberId();
+    this.changeRef.detectChanges();
+    this.policyForm.businessCycle = this.restApiService?.getBusinessCycle();
+  }
+
+  /**
+   * Displays the listing pages the left side of policy form to set and edit the dropdown fields values
+   * @param type holds name of particular list is to be displayed
+   * @param event contains boolean value to display the list or not
+   * @param workflowType it sets the approval workflow type while editing the approval workflow.
+   */
+  activateSelector(type: any, event: boolean, workflowType?: any) {
+    if (workflowType) {
+      this.workflowType = workflowType;
+    }
+    this.activeSelector = event ? type : '';
+    if (this.sideSelectorElements.includes(type)) {
+      this.pickerChanged.emit(event);
+    }
+  }
+
+  /**
+   * Closes the listing pages
+   */
+  disableSelector() {
+    this.addMoreLevels = false;
+    this.activeSelector = '';
+    this.pickerChanged.emit(false);
+  }
+
+  /**
+   * Fetches Responsibility centers list
+   */
+  getRCList() {
+    this.policyService.getRCList().subscribe(
+      (res) => {
+        this.rcList = res;
+        this.rcListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.rcListLoaded = true;
+      }
+    );
+  }
+
+  /**
+   * Fetches organization users list
+   */
+  getUsersList() {
+    this.policyService.getOrganizationPeople().subscribe(
+      (res: any) => {
+        if (this.groupEnabled) {
+          this.usersList = this.updateMemberIdKey(res);
+        } else {
+          this.usersList = res;
+        }
+        this.usersListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.usersListLoaded = true;
+      }
+    );
+  }
+
+  // replace member_id value to my_member_id
+  updateMemberIdKey(list: any) {
+    let updatedList = list.map((ele: any) => ({
+      ...ele,
+      member_id: ele?.my_member_id,
+    }));
+    return updatedList;
+  }
+
+  /**
+   * Fetches Policy Categories list
+   */
+  getCategoriesList() {
+    this.policyService.getCategoriesList().subscribe(
+      (res: any) => {
+        this.categoryList = res;
+        this.categoriesListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.categoriesListLoaded = true;
+      }
+    );
+  }
+
+  /**
+   * Fetches organization users groups list
+   */
+  getGroupsList() {
+    this.responsibilityService.getOrganizationPolicyGroups().subscribe(
+      (res: any) => {
+        const data = res.data;
+        const groups: any = [];
+        data?.forEach((element: any) => {
+          const obj = {
+            groupName: element.group_name,
+            userIds: element.member_ids,
+          };
+          groups.push(obj);
+        });
+        this.groupsList = groups;
+        if (this.groupEnabled) {
+          this.groupsList = data;
+        }
+        this.groupsListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.groupsListLoaded = true;
+      }
+    );
+  }
+
+  //Get the list of overseers group.
+  overseerGroupList() {
+    this.responsibilityService?.getOrganizationOverseersGroups().subscribe(
+      (res: any) => {
+        this.overseerGroupsList = res?.data;
+        this.groupsListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.groupsListLoaded = true;
+      }
+    );
+  }
+
+  /**
+   * Sets the approvers workflow from the selected workflow on Approvers workflow list
+   * @param event contains selected predefined workflow
+   */
+  selectedWorkflowChange(event: any) {
+    if (event === -1) {
+      // this.policyForm.selectedApprovers = [];
+      // this.addMoreLevels = true
+      // this.activateSelector('approvers', true);
+    } else {
+      let data = cloneDeep(event.approval_workflow);
+      const newArray = data.map((item: any) => {
+        item.name = item.type;
+        const ids = item.approvers.map((approver: any) => approver.member_id);
+        item.approvers = this.setList(this.allApprovers, ids, 'member_id');
+        return item;
+      });
+      this.policyForm.selectedApprovers = newArray.filter(
+        (level: any) => level.approvers.length > 0
+      );
+    }
+  }
+
+  /**
+   * Fetches Approvers workflow list based on selected policy categories
+   * @param id contains selected categories id's
+   */
+  getApproverWorkFlow(id: any, data?: any) {
+    this.loader = true;
+    this.policyService.getWorkflowList(id).subscribe(
+      (res: any) => {
+        if (res?.length >= 0) {
+          this.approverWorkFlowList = res; // getting all approver saved workflows
+          this.selectedWorkflow = [];
+          this.approverWorkFlowList?.forEach((workflow) => {
+            if (this.approvalWorkflowIds?.includes(workflow?._id)) {
+              this.selectedWorkflow?.push(workflow);
+            }
+          });
+
+          const approvalData: any = [];
+          if (!this.selectedWorkflow?.length) {
+            this.noWorkflowSelected = true;
+            let approvalWorkflow: any[] = [];
+            this.removeWorkflow();
+            Object.keys(this.defaultEditApprovers).forEach((approversLevel) => {
+              this.defaultEditApprovers[approversLevel].approvers =
+                this.defaultEditApprovers[approversLevel]?.approvers?.map(
+                  (app: any) => {
+                    if (!app.member_name) {
+                      const approverUser = this.usersList?.find(
+                        (user: any) => user.my_member_id == app.member_id
+                      );
+                      if (approverUser) {
+                        app.member_name = approverUser?.member_name;
+                      }
+                    }
+                    return app;
+                  }
+                );
+              approvalWorkflow.push({
+                level1: approversLevel,
+                ...this.defaultEditApprovers[approversLevel],
+              });
+            });
+            approvalData.push({
+              workflow_name: '',
+              workflow_module: 'POLICY',
+              description: {},
+              approval_workflow: approvalWorkflow,
+              category_arr: [],
+              creator: {},
+            });
+
+            if (this.selectedWorkflow?.length) {
+              this.selectedWorkflow[0].approval_workflow = approvalData;
+            }
+          }
+          this.policyForm.selectedApprovers = this.selectedWorkflow;
+          if (data) {
+            this.getApproversAndReviewersList(
+              id,
+              data,
+              [data.ReviewerMemberId],
+              data
+            );
+          }
+          this.loader = false;
+        }
+      },
+      (err) => {
+        console.error(err);
+        this.loader = false;
+      }
+    );
+  }
+
+  removeWorkflow() {
+    this.selectedWorkflow = [];
+    this.policyForm.selectedApprovers = [];
+    this.approvalWorkflowIds = [];
+    this.editApprovalWorkflow = undefined;
+  }
+
+  /**
+   * Fetches Approvers and reviewers list based on selected policy categories
+   * @param categoryIds contains selected categories id's
+   */
+  getApproversAndReviewersList(
+    categoryIds: any,
+    approverIds?: any,
+    reviewerIds?: any,
+    policy?: any
+  ) {
+    this.loader = true;
+    this.allApprovers = [];
+    this.allReviewers = [];
+    this.policyService.getReviewers(categoryIds).subscribe(
+      (res: any) => {
+        if (res?.length >= 0) {
+          res.forEach((element: any) => {
+            this.allApprovers = uniqBy(
+              this.allApprovers.concat(element.all_approvers),
+              'member_id'
+            );
+            this.allReviewers = uniqBy(
+              element.all_approvers.concat(
+                this.allReviewers,
+                element.all_authors
+              ),
+              'member_id'
+            );
+            if (this.mode === 'CREATE') this.setOwnersOnLoad();
+            if (policy?.policy_owners.length) {
+              this.policyForm.policy_owners = this.setList(
+                this.allApprovers,
+                policy?.policy_owners ?? [],
+                'member_id'
+              );
+            }
+            this.getUsersAccessListByCategory(element);
+          });
+        }
+        if (approverIds?.approvers) {
+          let obj = approverIds?.approvers;
+          let approverLevels = [];
+          // for (var item in obj) {
+          //   const ids = obj[item]?.approvers?.map(
+          //     (approver: any) => approver.member_id
+          //   );
+
+          //   let data = {
+          //     name: obj[item]?.type,
+          //     approvers: this.setList(this.allApprovers, ids, 'member_id'),
+          //   };
+          //   if (data.name == 'ROUNDROBIN') {
+          //     data.name = 'ROUND-ROBIN';
+          //   } else if (data.name == 'ANYONE') {
+          //     data.name = 'ANY ONE';
+          //   }
+          //   approverLevels.push(data);
+          // }
+          if (approverIds?.approvers) {
+            let obj = approverIds?.approvers;
+            let approverLevels = [];
+            for (var item in obj) {
+              const ids = obj[item]?.approvers?.map(
+                (approver: any) => approver.member_id
+              );
+              let data = {
+                type: obj[item]?.name ?? obj[item]?.type,
+                approvers: obj[item]?.approvers,
+                approval_done: false,
+                level1: obj[item]?.level1 || item,
+                alias_name: obj[item]?.alias_name,
+              };
+              if (data.type == 'ROUNDROBIN') {
+                data.type = 'ROUND-ROBIN';
+              } else if (data.type == 'ANYONE') {
+                data.type = 'ANY ONE';
+              }
+              approverLevels.push(data);
+            }
+            if (this.selectedWorkflow?.length) {
+              this.selectedWorkflow[0].approval_workflow = approverLevels;
+            } else {
+              this.selectedWorkflow = [
+                {
+                  approval_workflow: approverLevels,
+                },
+              ];
+            }
+            this.policyForm.selectedApprovers = this.selectedWorkflow;
+          }
+          if (reviewerIds) {
+            this.policyForm.selectedReviewers = this.setList(
+              this.allReviewers,
+              reviewerIds,
+              'member_id'
+            );
+          }
+          this.loader = false;
+        }
+      },
+      (err: Error) => {
+        console.error(err);
+        this.loader = false;
+      }
+    );
+  }
+
+  /*******
+   * It is to populate more options elements while editing the policy form
+   */
+  populateOptionalFields() {
+    const activatedOptions = [];
+    if (this.policyForm.addResponsibilityCenters) {
+      activatedOptions.push('RESPONSIBILITY_CENTER');
+    }
+    // if (this.policyForm.addReviewers) { activatedOptions.push('REVIEWER'); }
+    // if (this.policyForm.addCheckpoints) { activatedOptions.push('CHECKPOINTS'); }
+    if (this.policyForm.addOverseers) {
+      activatedOptions.push('OVERSEER');
+    }
+    if (this.policyForm.addAssociatedDocuments) {
+      activatedOptions.push('RELATED_DOCUMENTS');
+    }
+    if (this.policyForm.policy_version) {
+      activatedOptions.push('VERSION');
+    }
+
+    if (this.policyForm.assessment.length) {
+      activatedOptions.push('LINK_ASSESSMENTS');
+      this.getAssessmentDetails(this.policyForm.assessment[0]);
+    }
+    if (
+      this.policyForm?.programSelectedValues?.program &&
+      this.policyForm?.programSelectedValues?.program?.category_id
+    ) {
+      activatedOptions.push('LINK_PROGRAM_RESPONSIBILITIES');
+      this.policyForm.addLinkProgram = true;
+    }
+    this.populateOption.emit(activatedOptions);
+  }
+  /**
+   * It is to add and remove the elements from More option to the policy Form
+   * @param event contains details related to checked value, code particular elements from More options
+   */
+  addMoreInfo(event: any) {
+    switch (event.code) {
+      case 'RESPONSIBILITY_CENTER':
+        this.policyForm.addResponsibilityCenters = event.checked;
+        break;
+      // case 'REVIEWER':
+      //   this.policyForm.addReviewers = event.checked;
+      //   break;
+      case 'CHECKPOINTS':
+        this.policyForm.addCheckpoints = event.checked;
+        break;
+      case 'OVERSEER':
+        this.policyForm.addOverseers = event.checked;
+        break;
+      case 'RELATED_DOCUMENTS':
+        this.policyForm.addAssociatedDocuments = event.checked;
+        break;
+      case 'VERSION':
+        this.policyForm.addVersion = event.checked;
+        break;
+      case 'LINK_PROGRAM_RESPONSIBILITIES':
+        this.policyForm.addLinkProgram = event.checked;
+        break;
+      case 'LINK_ASSESSMENTS':
+        this.policyForm.addLinkAssessment = event.checked;
+        break;
+    }
+    this.scrollToBottom = true;
+  }
+
+  /**
+   * It is to ensure whether all required lists on Policy from is loaded from the api call or not
+   */
+  checkWhetherAllListsLoaded() {
+    if (
+      this.rcListLoaded &&
+      this.usersListLoaded &&
+      this.categoriesListLoaded &&
+      this.groupsListLoaded
+    ) {
+      this.refreshAllLists();
+      if (this.convertFileData && this.convertFileData.fileName) {
+        this.policyForm.policyName = this.convertFileData.fileName.substring(
+          0,
+          this.convertFileData.fileName.lastIndexOf('.')
+        );
+        if (this.convertFileData.categoryId) {
+          this.saveSelectedList('category', [this.convertFileData.categoryId]);
+        }
+      }
+      if (this.selectedCategory) {
+        this.saveSelectedList('category', [this.selectedCategory]);
+      }
+      if (this.mode === 'EDIT') {
+        this.editPolicy();
+      } else {
+        this.loader = false;
+      }
+    } else {
+      setTimeout(() => {
+        this.checkWhetherAllListsLoaded();
+      }, 300);
+    }
+  }
+
+  /**
+   * Triggers the confirmation popup when availability on Policy portal toggle in ON
+   * @param event contains toggle value which is always true or false
+   */
+  availabilityOnPortal(event: any) {
+    if (event) {
+      const confirmationDetails: ConfirmationAlert = {
+        isVisible: true,
+        message: `The policies that you intend to make accessible to the entire organization can be added to the policy portal.
+        It is like a shared catalog of all active & updated policies that any logged in user can read/ download for reference.
+        Hence, if this option is enabled, it is not necessary for you to set up an attestation schedule or select
+        readers to attest the policies.`,
+        action: 'POLICY_PORTAL',
+      };
+      this.showConfirmationAlert.emit(confirmationDetails);
+    }
+  }
+
+  /**
+   * Receives the input from the Confirmation dialog of available on Policy portal
+   * @param event contains selected option from the confirmation dialog which is always either 'YES' or 'NO'
+   */
+  confirmPolicyPortal(event: any) {
+    this.policyForm.availableOnPortal = event == 'YES' ? true : false;
+    if (event == 'NO') {
+      this.policyForm.acceptSuggestions = false;
+    }
+  }
+
+  /**
+   * Sets the policyForm with selected elements from the listing, frequency, file upload components
+   * @param type defines the particular field on Policy form.
+   * @param selectedItems contains the list of selected items from the list
+   */
+  saveSelectedList(type: string, selectedItems: any) {
+    switch (type) {
+      case 'rc':
+        this.policyForm.selectedRCs = this.setList(
+          this.rcList,
+          selectedItems,
+          'item_id'
+        );
+        break;
+      case 'category':
+        this.policyForm.selectedCategories = this.setList(
+          this.categoryList,
+          selectedItems,
+          '_id'
+        );
+        const objectIds = this.returnIds(
+          this.policyForm.selectedCategories,
+          '_id'
+        );
+        this.policyForm.selectedApprovers = [];
+        this.policyForm.selectedReviewers = [];
+        this.resetPolicyAccessDetails();
+        this.resetReviewerFrequency();
+        this.policyForm.customTags = [];
+        this.getApproverWorkFlow(objectIds);
+        this.getApproversAndReviewersList(objectIds);
+        this.policyForm.selectedCategories.forEach((element: any) => {
+          const tag = element.custom_tags;
+          if (tag.length > 0) {
+            tag.forEach((tagData: any) => {
+              const index = this.policyForm.customTags.findIndex(
+                (tagElement: any) => tagElement.tagname == tagData.tagname
+              );
+              if (index == -1) {
+                this.policyForm.customTags.push(tagData);
+              }
+            });
+          }
+        });
+
+        break;
+      case 'assignees':
+        let userIds, groupIds;
+        if (this.groupEnabled) {
+          userIds = this.returnIds(selectedItems.users, 'member_id');
+          groupIds = this.returnIds(selectedItems.groups, 'group_id');
+          this.policyForm.selectedGroupAssignee = this.setList(
+            this.groupsList,
+            groupIds,
+            'group_id'
+          );
+        } else {
+          userIds = selectedItems;
+        }
+        this.policyForm.selectedAssignees = this.setList(
+          this.assigneesList,
+          userIds,
+          'my_member_id'
+        );
+        this.refreshAllLists();
+        break;
+
+      case 'reviewer':
+        this.policyForm.selectedReviewers = this.setList(
+          this.allReviewers,
+          [selectedItems.member_id],
+          'member_id'
+        );
+        break;
+      case 'ccEmail':
+        let selectedUserIds, selectedGroupIds;
+        if (this.groupEnabled) {
+          selectedUserIds = this.returnIds(selectedItems?.users, 'member_id');
+          selectedGroupIds = this.returnIds(selectedItems?.groups, 'group_id');
+          this.policyForm.CCGroupEmail = this.setList(
+            this.overseerGroupsList,
+            selectedGroupIds,
+            'group_id'
+          );
+          this.policyForm.CCEmail = this.setList(
+            this.usersList,
+            selectedUserIds,
+            'my_member_id'
+          );
+          this.ccEmailObjIds = this.getGroupObjectId(
+            this.policyForm?.CCGroupEmail
+          );
+        } else {
+          this.policyForm.CCEmail = this.setList(
+            this.usersList,
+            selectedItems,
+            'employee_id'
+          );
+        }
+        this.refreshAllLists();
+        break;
+      case 'ccFail':
+        let selectedFailUserIds, selectedFailGroupIds;
+        if (this.groupEnabled) {
+          selectedFailUserIds = this.returnIds(
+            selectedItems?.users,
+            'member_id'
+          );
+          selectedFailGroupIds = this.returnIds(
+            selectedItems?.groups,
+            'group_id'
+          );
+          this.policyForm.CCFailEmailGroup = this.setList(
+            this.overseerGroupsList,
+            selectedFailGroupIds,
+            'group_id'
+          );
+          this.policyForm.CCFailEmail = this.setList(
+            this.usersList,
+            selectedFailUserIds,
+            'my_member_id'
+          );
+          this.ccFailGroupObjIds = this.getGroupObjectId(
+            this.policyForm?.CCFailEmailGroup
+          );
+        } else {
+          this.policyForm.CCFailEmail = this.setList(
+            this.usersList,
+            selectedItems,
+            'employee_id'
+          );
+        }
+        this.refreshAllLists();
+        break;
+      case 'approvers':
+        const approvers = this.setList(
+          this.allApprovers,
+          selectedItems,
+          'member_id'
+        );
+        if (this.addMoreLevels) {
+          this.policyForm.selectedApprovers.push({
+            name: this.workflowType,
+            approvers,
+          });
+          this.addMoreLevels = false;
+          this.disableSelector();
+          return;
+        }
+        this.policyForm.selectedApprovers[this.approversListIndex] = {
+          name: this.workflowType,
+          approvers,
+        };
+        break;
+      case 'reviewer_attachments':
+        this.policyForm.documentsAndLinks.formatFiles =
+          selectedItems?.files ?? [];
+
+        this.policyForm.documentsAndLinks.formatLinks =
+          selectedItems?.links ?? [];
+        break;
+      case 'associatedDocuments':
+        this.policyForm.associatedDocuments.formatFiles =
+          selectedItems?.files ?? [];
+
+        break;
+      case 'checkpoints':
+        this.policyForm.checkpointDetails =
+          selectedItems?.checkpointDetails ?? [];
+        this.policyForm.totalQuestion =
+          selectedItems?.checkpointDetails?.length ?? 0;
+        this.policyForm.passingMarks = selectedItems?.requiredPoint ?? 0;
+        break;
+      case 'owners':
+        this.policyForm.policy_owners = this.setList(
+          this.allApprovers,
+          selectedItems,
+          'member_id'
+        );
+        break;
+      case 'policyAccess':
+        let accessIds, accessGroupIds;
+        this.policyForm.availableOnPortal =
+          selectedItems?.futureUsersWillSelect;
+        if (this.groupEnabled) {
+          accessIds = this.returnIds(selectedItems.users, 'member_id');
+          accessGroupIds = this.returnIds(selectedItems.groups, 'group_id');
+          this.policyForm.policy_access_groups = this.setList(
+            this.overseerGroupsList,
+            accessGroupIds,
+            'group_id'
+          );
+        } else {
+          accessIds = selectedItems;
+        }
+        this.policyForm.policy_access_owners = this.setList(
+          this.assigneesList,
+          accessIds,
+          'my_member_id'
+        );
+        this.refreshAllLists();
+        break;
+    }
+    this.disableSelector();
+  }
+
+  //return the _id from the selected overseer group.
+  getGroupObjectId(overseerGroup?: any) {
+    let overseerGroupIdArray = overseerGroup.map((ele: any) => ele._id);
+    return overseerGroupIdArray;
+  }
+
+  /**
+   * Removes the particular element from selected list
+   * @param type defines the particular case
+   * @param event holds the id or key of element to be removed
+   * @param removeIndex contains the index of the element to be removed
+   */
+  remove(type: any, event: any, removeIndex?: any) {
+    switch (type) {
+      case 'rc':
+        const rcIndex = this.policyForm.selectedRCs.findIndex(
+          (rc: any) => rc.rc_id == event.rc_id
+        );
+        this.policyForm.selectedRCs.splice(rcIndex, 1);
+        break;
+      case 'assignees':
+        const entrustIndex = this.policyForm.selectedAssignees.findIndex(
+          (owner: any) => owner.employee_id == event.employee_id
+        );
+        this.policyForm.selectedAssignees.splice(entrustIndex, 1);
+        this.refreshAllLists();
+        break;
+      case 'groupAssignees':
+        const groupIndex: any =
+          this.policyForm.selectedGroupAssignee?.findIndex(
+            (group: any) => group.group_id == event.group_id
+          );
+        this.policyForm.selectedGroupAssignee?.splice(groupIndex, 1);
+        break;
+      case 'reviewer':
+        const reviewerIndex = this.policyForm.selectedReviewers.findIndex(
+          (reviewer: any) => reviewer.member_id == event.member_id
+        );
+        this.policyForm.selectedReviewers.splice(reviewerIndex, 1);
+        this.resetReviewerFrequency();
+        break;
+      case 'ccEmail':
+        const overseerIndex = this.policyForm.CCEmail.findIndex(
+          (overseer: any) => overseer.employee_id == event.employee_id
+        );
+        this.policyForm.CCEmail.splice(overseerIndex, 1);
+        this.refreshAllLists();
+        break;
+      case 'ccGroupEmail':
+        const ccGroupIndex: any = this.policyForm?.CCGroupEmail?.findIndex(
+          (group: any) => group?.group_id == event?.group_id
+        );
+        this.policyForm.CCGroupEmail?.splice(ccGroupIndex, 1);
+        this.ccEmailObjIds = this.getGroupObjectId(
+          this.policyForm?.CCGroupEmail
+        );
+        this.refreshAllLists();
+        break;
+      case 'ccFail':
+        const overseerNotifyIndex = this.policyForm.CCFailEmail.findIndex(
+          (overseerN: any) => overseerN.employee_id == event.employee_id
+        );
+        this.policyForm.CCFailEmail.splice(overseerNotifyIndex, 1);
+        this.refreshAllLists();
+        break;
+      case 'ccGroupFailEmail':
+        const ccFailGroupIndex: any =
+          this.policyForm?.CCFailEmailGroup?.findIndex(
+            (group: any) => group?.group_id == event?.group_id
+          );
+        this.policyForm.CCFailEmailGroup?.splice(ccFailGroupIndex, 1);
+        this.ccFailGroupObjIds = this.getGroupObjectId(
+          this.policyForm?.CCFailEmailGroup
+        );
+        this.refreshAllLists();
+        break;
+      case 'approvers':
+        const approversIndex = this.policyForm.selectedApprovers[
+          removeIndex
+        ].approvers.findIndex(
+          (approver: any) => approver.member_id == event.member_id
+        );
+        this.policyForm.selectedApprovers[removeIndex].approvers.splice(
+          approversIndex,
+          1
+        );
+        if (
+          this.policyForm.selectedApprovers[removeIndex].approvers.length == 0
+        ) {
+          this.policyForm.selectedApprovers.splice(removeIndex, 1);
+        }
+        break;
+      case 'category':
+        const categoryIndex = this.policyForm.selectedCategories.findIndex(
+          (category: any) => category.item_id == event.item_id
+        );
+        this.policyForm.selectedCategories.splice(categoryIndex, 1);
+        const tag = event.custom_tags;
+        if (tag.length > 0) {
+          tag.forEach((tagData: any) => {
+            const indexCT = this.policyForm.customTags.findIndex(
+              (tagElement: any) => tagElement.tagname == tagData.tagname
+            );
+            if (indexCT != -1) {
+              this.policyForm.customTags.splice(indexCT, 1);
+            }
+          });
+        }
+        const objectIds = this.returnIds(
+          this.policyForm.selectedCategories,
+          '_id'
+        );
+        this.resetReviewerFrequency();
+        this.policyForm.selectedApprovers.splice(
+          0,
+          this.policyForm.selectedApprovers.length
+        );
+
+        this.policyForm = Object.assign(this.policyForm);
+        this.policyForm.selectedReviewers = [];
+        this.getApproverWorkFlow(objectIds);
+        this.getApproversAndReviewersList(objectIds);
+        this.resetPolicyAccessDetails();
+
+        break;
+      case 'checkpoints':
+        this.policyForm?.checkpointDetails.splice(removeIndex, 1);
+        this.policyForm.totalQuestion -= 1;
+        this.policyForm.passingMarks -= 1;
+        break;
+      case 'workflowLevel':
+        this.policyForm?.selectedApprovers.splice(removeIndex, 1);
+        this.removeWorkflow();
+        break;
+      case 'linkProgram':
+        this.policyForm.linkProgram = {
+          added: [],
+          removed: [
+            {
+              policyIds: [this.policyForm?.policy_id ?? 0],
+              programId: this.selectedLinkProgram?._id,
+            },
+          ],
+        };
+        this.policyForm.programSelectedValues = {};
+        this.refreshAllLists();
+        break;
+
+      case 'owners':
+        this.policyForm?.policy_owners.splice(removeIndex, 1);
+        break;
+      case 'policyAccess':
+        const userAccessIndex = this.policyForm?.policy_access_owners.findIndex(
+          (owner: any) => owner?.employee_id == event?.employee_id
+        );
+        this.policyForm?.policy_access_owners?.splice(userAccessIndex, 1);
+        this.refreshAllLists();
+        break;
+      case 'accessGroup':
+        const groupAccessIndex: any =
+          this.policyForm?.policy_access_groups?.findIndex(
+            (group: any) => group?.group_id == event?.group_id
+          );
+        this.policyForm?.policy_access_groups?.splice(groupAccessIndex, 1);
+        break;
+    }
+  }
+  /**
+   * Refreshes the assignees and overseers list such that both list does not contain the same users based on selection
+   */
+  refreshAllLists() {
+    let assigneesIds: any = [];
+    let reviewersIds: any = [];
+    let overseerIds: any = [];
+    const allUsers = cloneDeep(this.usersList);
+    const assignees = cloneDeep(this.policyForm.selectedAssignees);
+    const overseerList = cloneDeep(this.policyForm.CCEmail);
+    const notifyOverseers = cloneDeep(this.policyForm.CCFailEmail);
+    assignees?.forEach((user: any) => {
+      assigneesIds.push(user.employee_id);
+    });
+    overseerList?.forEach((user: any) => {
+      overseerIds.push(user.employee_id);
+    });
+    notifyOverseers?.forEach((user: any) => {
+      overseerIds.push(user.employee_id);
+    });
+
+    assigneesIds = [...new Set(assigneesIds)];
+    reviewersIds = [...new Set(reviewersIds)];
+    overseerIds = [...new Set(overseerIds)];
+
+    // this.assignorsList = behalfUsers.filter((user: any) => !(reviewersIds.includes(user.member_id) || overseerIds.includes(user.member_id)));
+    this.assigneesList = allUsers.filter(
+      (user: any) =>
+        !(
+          reviewersIds.includes(user.employee_id) ||
+          overseerIds.includes(user.employee_id)
+        )
+    );
+    if (this.groupEnabled) {
+      const userObj = this.assigneesList;
+      userObj?.forEach((user: any) => {
+        user.member_id = user.my_member_id;
+      });
+      this.ownerlist = userObj;
+    }
+    // this.reviewersList = allUsers.filter((user: any) => !(assigneesIds.includes(user.employee_id) || overseerIds.includes(user.employee_id)));
+    this.overseersList = allUsers.filter(
+      (user: any) =>
+        !(
+          assigneesIds.includes(user.employee_id) ||
+          reviewersIds.includes(user.employee_id)
+        )
+    );
+  }
+
+  /**
+   * Returns whole list based on selected id's from a particular list elements
+   * @param list it is the main list  which contains all elements list
+   * @param key contains key to filter selected list from the list
+   * @param ids selected ids array
+   */
+  setList(list: any[], ids: any[], key: string) {
+    const data: any = [];
+    ids?.forEach((element: any) => {
+      const index = list?.findIndex(
+        (listElement: any) => listElement[key] == element
+      );
+      if (index !== -1) {
+        data.push(list[index]);
+      }
+    });
+    return data;
+  }
+
+  /**
+   * Returns id's from a particular list elements
+   * @param list actual selected list
+   * @param key contains key to extract id from the list
+   */
+  returnIds(list: any[], key: string) {
+    return list.map((ele) => {
+      if (ele[key]) {
+        return ele[key];
+      }
+    });
+  }
+
+  /**
+   * Sets the reviewer type in approval workflow
+   * @param event contains selected reviewer type
+   */
+  reviewerTypeChange(event: any) {
+    this.workflowType = event;
+  }
+
+  /**
+   * Sets frequency in edit  mode
+   */
+  frequencyDataPopulation(event: any, mode: 'SELECT' | 'POPULATE' = 'SELECT') {
+    //needs to discuss with backend about edit and default values
+    const data = {
+      pattern: event?.frequency_details, //
+      window: event?.remind_days_before_due_date,
+      failedAfter: event?.mark_failed_after,
+      failed_time_utc: '',
+      lifecycleDetails: '0000-00-00~~0',
+      timeIn24Hr: event.failed_time != '' ? event.failed_time : '23:59:00',
+      continuous_failed_days: 0,
+      startFrom: Math.floor(
+        new Date(event.assignee_start_date).getTime() / 1000
+      ),
+      startDate: '',
+      reportId: 0,
+      timeIn12hr: this.frequencyService.timeIn12(
+        event.failed_time != '' ? event.failed_time : '23:59:00'
+      ),
+      placeholder: event.frequency_text,
+    };
+
+    this.frequencyData(data);
+  }
+
+  /**
+   * Sets the selected frequency details in the policyForm
+   * @param event contains selected frequency details
+   */
+  frequencyData(event: any) {
+    this.policyForm.frequency_details = event.pattern;
+    (this.policyForm.frequency_text = event.placeholder),
+      (this.policyForm.mark_failed_after = event.failedAfter);
+    this.policyForm.remind_days_before_due_date = event.window;
+    this.policyForm.failed_time = event.timeIn24Hr;
+    this.policyForm.assignee_start_date = moment(event.startFrom * 1000).format(
+      'ddd MMM DD YYYY'
+    );
+    this.activateSelector('frequency', false);
+    const payload = {
+      frequency_details: event.pattern,
+      frequency_time: event.timeIn12hr,
+      reminder_before_days: event.window,
+      failed_after_days: event.failedAfter,
+      lifecycle_details: event.lifecycleDetails,
+      start_of_day_utc: event.startFrom,
+      on_completion_of: [event.reportId],
+      dom_utc: Math.floor(Date.now() / 1000),
+      continuous_failed_days: event.continuous_failed_days,
+      placeholder: event.placeholder,
+    };
+    this.frequencyPopulation(payload);
+  }
+
+  /**
+   * Populates the frequency field with selected data from frequency component
+   * @param event contains selected frequency details
+   */
+  frequencyPopulation(event: any) {
+    this.frequencyDetails.pattern = event?.frequency_details;
+    this.frequencyDetails.failedTime = event?.frequency_time;
+    this.frequencyDetails.window = event?.reminder_before_days;
+    this.frequencyDetails.failed = event?.failed_after_days;
+    this.frequencyDetails.lifecycle = event?.lifecycle_details;
+    this.frequencyDetails.startDate = event?.start_of_day_utc;
+    this.frequencyDetails.selectedReport = event?.on_completion_of[0] ?? 0;
+    this.frequencyDetails.dateOfModified = event?.dom_utc;
+    this.frequencyDetails.continuous_failed_days = 3;
+    this.frequencyPlaceholder = event?.placeholder
+      ? event.placeholder
+      : 'How often does this policy need to be attested?';
+  }
+
+  reviewerFrequencyDataPopulation(event: any) {
+    //needs to discuss with backend about edit and default values
+    const data = {
+      pattern: event?.review_frequency_details, //
+      window: event?.review_remind_days_before_due_date,
+      failedAfter: event?.reviewFailedAfter,
+      failed_time_utc: '',
+      lifecycleDetails: '0000-00-00~~0',
+      timeIn24Hr:
+        event.reviewFailedTime != '' ? event.reviewFailedTime : '23:59:00',
+      continuous_failed_days: 0,
+      startFrom: Math.floor(
+        new Date(event.reviewer_start_date).getTime() / 1000
+      ),
+      startDate: '',
+      reportId: 0,
+      timeIn12hr: this.frequencyService.timeIn12(
+        event.reviewFailedTime != '' ? event.reviewFailedTime : '23:59:00'
+      ),
+      placeholder: event.reviewfrequencyDetails,
+    };
+
+    this.reviewerFrequencyData(data);
+  }
+
+  resetReviewerFrequency() {
+    this.reviewerFrequencyDetails = {
+      pattern: '',
+      notificationPending: 0,
+      dateOfModified: 0,
+      deactivationValue: 0,
+      selectedReport: 0,
+      lifecycle: '0000-00-00~~0',
+      startDate: Math.floor(new Date().getTime() / 1000),
+      startOnTheDay: Math.floor(new Date().getTime() / 1000),
+      window: 0,
+      failed: 0,
+      time: '11:59 pm',
+      failedTime: '',
+      continuous_failed_days: 3,
+    };
+    this.policyForm.reviewFailedAfter = 0;
+    this.policyForm.review_frequency_details = '';
+    this.policyForm.review_frequency_type = '';
+    this.policyForm.review_remind_days_before_due_date = 0;
+    this.policyForm.reviewFailedTime = '23:59:00';
+    this.reviewerFrequencyPlaceholder =
+      'When does this policy need to be reviewed ?';
+  }
+
+  /**
+   * Sets the selected reviewer frequency details in the policyForm
+   * @param event contains selected frequency details
+   */
+  reviewerFrequencyData(event: any) {
+    this.policyForm.reviewFailedAfter = event.failedAfter;
+    this.policyForm.review_frequency_details = event.pattern;
+    this.policyForm.review_frequency_type = event.pattern.split('~')[0];
+    this.policyForm.review_remind_days_before_due_date = event.window;
+    this.policyForm.reviewFailedTime = event.timeIn24Hr;
+    this.policyForm.reviewer_start_date = moment(event.startFrom * 1000).format(
+      'ddd MMM DD YYYY'
+    );
+
+    this.activateSelector('reviewerFrequency', false);
+    const payload = {
+      frequency_details: event.pattern,
+      frequency_time: event.timeIn12hr,
+      reminder_before_days: event.window,
+      failed_after_days: event.failedAfter,
+      lifecycle_details: event.lifecycleDetails,
+      start_of_day_utc: event.startFrom,
+      on_completion_of: [event.reportId],
+      dom_utc: Math.floor(Date.now() / 1000),
+      continuous_failed_days: event.continuous_failed_days,
+      placeholder: event.placeholder,
+    };
+    this.reviewerFrequencyPopulation(payload);
+  }
+
+  /**
+   * Populates the reviewer frequency field with selected data from frequency component
+   * @param event contains selected frequency details
+   */
+  reviewerFrequencyPopulation(event: any) {
+    this.reviewerFrequencyDetails.pattern = event?.frequency_details;
+    this.reviewerFrequencyDetails.failedTime = event?.frequency_time;
+    this.reviewerFrequencyDetails.window = event?.reminder_before_days;
+    this.reviewerFrequencyDetails.failed = event?.failed_after_days;
+    this.reviewerFrequencyDetails.lifecycle = event?.lifecycle_details;
+    this.reviewerFrequencyDetails.startDate = event?.start_of_day_utc;
+    this.reviewerFrequencyDetails.selectedReport =
+      event?.on_completion_of[0] ?? 0;
+    this.reviewerFrequencyDetails.dateOfModified = event?.dom_utc;
+    this.reviewerFrequencyDetails.continuous_failed_days = 3;
+    this.reviewerFrequencyPlaceholder = event?.placeholder
+      ? event.placeholder
+      : 'When does this policy need to be reviewed ?';
+  }
+
+  /**
+   * Validates the data submitted on create policy form
+   */
+  validatePolicy() {
+    setTimeout(() => {
+      this.submitted = true;
+    }, 100);
+    const event = this.policyForm.policyName;
+    const re = /&nbsp;|<br>/g;
+    this.policyForm.policyName = event.replace(re, '').trim();
+
+    if (
+      this.policyForm.policyName.trim() == '' ||
+      (!this.policyForm?.frequency_details &&
+        ((this.policyForm?.selectedAssignees?.length > 0 &&
+          !this.groupEnabled) ||
+          ((this.policyForm?.selectedAssignees?.length > 0 ||
+            this.policyForm?.selectedGroupAssignee?.length > 0) &&
+            this.groupEnabled))) ||
+      (this.policyForm?.frequency_details &&
+        this.policyForm?.selectedAssignees?.length == 0 &&
+        (!this.groupEnabled ||
+          (this.policyForm?.selectedGroupAssignee?.length == 0 &&
+            this.groupEnabled))) ||
+      (!this.policyForm.review_frequency_details &&
+        this.policyForm.selectedReviewers.length > 0) ||
+      (this.policyForm.review_frequency_details &&
+        this.policyForm.selectedReviewers.length == 0) ||
+      this.policyForm.selectedCategories.length == 0 ||
+      (!this.policyForm?.selectedApprovers[0]?.approval_workflow?.length &&
+        !this.policyForm?.selectedApprovers[0]?.approvers?.length &&
+        this.policyApprovalFlag === 0) ||
+      (this.formatEvidence && this.formatEvidence.newLink.containsError) ||
+      !this.policyForm.policy_owners?.length ||
+      (this.isSendForAttestation &&
+        this.policyForm?.selectedAssignees.length === 0)
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * Makes an api call to create a policy
+   * @param policy contains policyForm data
+   */
+  submitPolicy() {
+    this.submitted = false;
+    const valid = this.validatePolicy();
+    if (!valid || !this.isVersionValid) {
+      return false;
+    }
+    this.loader = true;
+    this.uiKitService.isLoader = true;
+    if (this.noWorkflowSelected) {
+      this.policyForm.selectedApprovers = this.selectedWorkflow;
+    }
+    const policy = this.policyForm;
+    let approversData: any = this.convertApprovalWorkflow(
+      policy.selectedApprovers
+    );
+    let reviewerFilesArray = cloneDeep(policy.documentsAndLinks.formatFiles);
+    const reviewerFiles = reviewerFilesArray.map((file: any) => {
+      file.name = file.filename;
+      file.file_path = file.filepath;
+      file.org_name = file.original_filename;
+      delete file.filename;
+      delete file.filepath;
+      delete file.original_filename;
+      delete file.linkSet;
+      return file;
+    });
+
+    let attestationFilesArray = cloneDeep(
+      policy.associatedDocuments.formatFiles
+    );
+    const attestationFiles = attestationFilesArray.map((ele: any) => {
+      ele.name = ele.filename;
+      ele.file_path = ele.filepath;
+      ele.original_file_name = ele.original_filename;
+      ele.folder_id = ele?.folder_id ? ele.folder_id : 0;
+      ele.path = ele?.path ? ele.path : ele.filepath + ele.filename;
+      ele.isLinkSet = ele.linkSet;
+      ele.other_type = ele?.others;
+      delete ele.filename;
+      delete ele.filepath;
+      delete ele.original_filename;
+      delete ele.linkSet;
+      delete ele.file_name;
+      delete ele.others;
+      return ele;
+    });
+    const reviewerID = this.returnIds(policy.selectedReviewers, 'member_id');
+    const policyAccessUsersIds =
+      this.returnIds(policy.policy_access_owners, 'member_id') ?? [];
+    const policyAccessGroupsIds =
+      this.returnIds(policy.policy_access_groups, '_id') ?? [];
+
+    const payload = {
+      policy_name: policy.policyName,
+      notes: policy.policyNotes,
+      is_portal_enable: policy.availableOnPortal ? 1 : 0,
+      is_suggetion_enable: policy.acceptSuggestions ? 1 : 0,
+      category_id_arr: this.returnIds(policy.selectedCategories, 'item_id'),
+      approvers: approversData,
+      group_employeeIds: this.returnIds(
+        policy?.selectedAssignees,
+        'employee_id'
+      ).toString(),
+      usergroup_ids: this.returnIds(policy.selectedGroupAssignee, '_id') ?? [],
+      Is_approval: 0, //needs to check in fe
+
+      associated_documents: policy.addAssociatedDocuments
+        ? attestationFiles
+        : [],
+
+      custom_tags: JSON.stringify(policy.customTags),
+
+      frequency_details: policy.frequency_details
+        ? policy.frequency_details
+        : '',
+      frequency_text: policy.frequency_details ? policy.frequency_text : '',
+      remind_days_before_due_date: policy.frequency_details
+        ? policy.remind_days_before_due_date
+        : 0,
+      failed_time: policy.frequency_details ? policy.failed_time : '',
+      mark_failed_after: policy.frequency_details
+        ? policy.mark_failed_after
+        : '',
+      // startDate: policy.policyDueDate.toDateString(),
+      startDate: moment(policy.policyDueDate).format('ddd MMM DD YYYY'),
+
+      ReviewerAttachments:
+        policy.addReviewers && policy.documentsAndLinks.formatFiles
+          ? reviewerFiles
+          : [],
+      ReviewerLinks:
+        policy.addReviewers && policy.documentsAndLinks.formatLinks
+          ? policy.documentsAndLinks.formatLinks
+          : [],
+      ReviewerMemberId:
+        policy.addReviewers && reviewerID[0] ? reviewerID[0] : 0,
+      isReview:
+        policy.addReviewers &&
+        (policy.documentsAndLinks.formatFiles ||
+          policy.documentsAndLinks.formatLinks) &&
+        reviewerID[0]
+          ? 1
+          : 0,
+
+      reviewFailedAfter:
+        policy.addReviewers && policy.review_frequency_details
+          ? policy.reviewFailedAfter
+          : 0,
+      reviewFailedTime:
+        policy.addReviewers && policy.review_frequency_details
+          ? policy.reviewFailedTime
+          : '',
+      review_frequency_details:
+        policy.addReviewers && policy.review_frequency_details
+          ? policy.review_frequency_details
+          : '',
+      review_frequency_type:
+        policy.addReviewers && policy.review_frequency_details
+          ? policy.review_frequency_type
+          : '',
+      review_remind_days_before_due_date:
+        policy.addReviewers && policy.review_frequency_details
+          ? policy.review_remind_days_before_due_date
+          : 0,
+
+      entities: this.policyForm?.addResponsibilityCenters
+        ? this.returnIds(policy.selectedRCs, 'item_id').toString()
+        : '',
+      risk_class: policy.riskRating.toString(),
+
+      CCFailEmail: policy.addOverseers
+        ? this.returnIds(policy.CCFailEmail, 'employee_email').toString()
+        : '',
+      CCEmail: policy.addOverseers
+        ? this.returnIds(policy.CCEmail, 'employee_email').toString()
+        : '',
+
+      checkpointDetails: policy.checkpointDetails ?? [],
+      totalQuestion: policy.totalQuestion ? policy.totalQuestion : 0, //
+      passingMarks: policy.passingMarks ? policy.passingMarks : 0, //
+
+      policyApprovalFlag: 0,
+
+      is_signature_required: policy.requiresSignatureForAttestation ? 1 : 0,
+      cc_usergroup_ids: this.ccEmailObjIds,
+      cc_fail_usergroup_ids: this.ccFailGroupObjIds,
+      reviewer_start_date: policy.reviewer_start_date ?? '',
+      assignee_start_date: policy.assignee_start_date,
+      policy_version: policy.addVersion ? policy.policy_version : '',
+      assessment: policy.addLinkAssessment
+        ? policy.assessment.map((ele: any) => {
+            return {
+              assessment_id: ele.assessment_id,
+              category_id: ele.category_id,
+            };
+          })
+        : [],
+      policy_owners: this.policyForm.policy_owners.map(
+        (ele: any) => ele.member_id
+      ),
+      approval_workflow_id: policy?.selectedApprovers[0]?._id
+        ? [policy?.selectedApprovers[0]?._id]
+        : [],
+      linkProgram: Object.keys(policy?.linkProgram).length
+        ? policy?.linkProgram
+        : {
+            added: [],
+            removed: [],
+          },
+      business_cycle: Object.keys(policy?.linkProgram).length
+        ? policy?.businessCycle
+        : undefined,
+      policy_access_type: policy.policy_access_type ?? 0,
+      policy_access_owners: policy.availableOnPortal
+        ? []
+        : policyAccessUsersIds ?? [],
+      policy_access_groups: policy.availableOnPortal
+        ? []
+        : policyAccessGroupsIds ?? [],
+    };
+    if (this.mode == 'CREATE') {
+      this.policyService.submitPolicy(payload).subscribe(
+        (res: any) => {
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+          this.policyId = res._id;
+          if (this.convertFileData?.fileName) {
+            this.loader = true;
+            this.linkDocumentWithPolicy(this.convertFileData);
+            return;
+          }
+          this.pickerChanged.emit(true);
+          this.showCreateDocuments = true;
+        },
+        (err) => {
+          console.error(err);
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+          this.snackBar.show(
+            'OOPS! Something went wrong and the page could not be loaded. Could you please try one more time?',
+            'alert'
+          );
+        }
+      );
+    }
+    if (this.mode == 'EDIT') {
+      if (this.policyApprovalFlag !== 0) {
+        delete payload.approvers;
+        payload.policyApprovalFlag = 2;
+      }
+      this.policyService.updatePolicy(payload, this.policyId).subscribe(
+        (res: any) => {
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+          this.policyId = res._id;
+
+          if (this.navigateToDocumentsSection) {
+            this.pickerChanged.emit(true);
+            this.showCreateDocuments = true;
+          } else {
+            this.disconnectRefresh.emit(false);
+            if (this.isSendForAttestation) {
+              this.snackBar.show(
+                'The policy has been sent for attestation',
+                'success'
+              );
+            } else {
+              this.snackBar.show('The policy has been updated', 'success');
+            }
+            window.location.href =
+              this.baseURL + '/all/policy/workroom?id=' + this.policyId;
+            // this.router.navigate(['/policy/workroom'], { queryParams: { id: this.policyId }, relativeTo: this.route });
+            // window.location.reload();
+          }
+        },
+        (err) => {
+          console.error(err);
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+          this.snackBar.show(
+            'OOPS! Something went wrong and the page could not be loaded. Could you please try one more time?',
+            'alert'
+          );
+        }
+      );
+    }
+  }
+
+  linkDocumentWithPolicy(document: any) {
+    if (
+      document.fileName &&
+      (document.fileExtension === 'pdf' ||
+        document.fileExtension === 'PDF' ||
+        document.fileExtension === 'docx' ||
+        document.fileExtension === 'DOCX')
+    ) {
+      this.policyService
+        .extractFile(document.fileExtension, document.filePath, this.policyId)
+        .subscribe(
+          (res: any) => {
+            if (res) {
+              if (res.message === 'done' || res.content) {
+                this.loader = false;
+                if (
+                  document.fileExtension === 'docx' ||
+                  document.fileExtension === 'DOCX'
+                ) {
+                  this.router.navigate(['/policy/edit-policy'], {
+                    queryParams: { id: this.policyId },
+                    relativeTo: this.route,
+                  });
+                } else if (
+                  document.fileExtension === 'pdf' ||
+                  document.fileExtension === 'PDF'
+                ) {
+                  this.router.navigate(['/policy/workroom'], {
+                    queryParams: { id: this.policyId },
+                    relativeTo: this.route,
+                  });
+                }
+              }
+            }
+          },
+          (err: any) => {
+            this.loader = false;
+            console.error(err);
+            this.snackBar.show(
+              "Oops! Something went wrong and we were unable to complete this action. Let's give it another try, shall we?",
+              'alert'
+            );
+          }
+        );
+    } else {
+      this.loader = false;
+      this.snackBar.show(
+        "Oops! Something went wrong and we were unable to complete this action. Let's give it another try, shall we?",
+        'alert'
+      );
+    }
+  }
+
+  /**
+   * opens the date picker on policy form
+   */
+  openDatePicker() {
+    this.datePicker.api.open();
+    this.datePickerOverlay = true;
+    // this.setActiveFieldSelector('ISSUE_DATE_TIME', 'ISSUE_DATE_TIME');
+  }
+
+  /**
+   * closes the date picker from policy form
+   */
+  closeDatePicker(evt: any) {
+    this.datePickerOverlay = false;
+
+    if (!evt) {
+      return;
+    }
+    if (evt?.date?._d) {
+      let monthArray = [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec',
+      ];
+      const dateValue = new Date(evt?.date?._d).getDate();
+      const monthValue = monthArray[new Date(evt?.date?._d).getMonth()];
+      const yearValue = new Date(evt?.date?._d).getFullYear();
+      const dateStr = `${dateValue} ${monthValue} ${yearValue}`;
+    }
+    if (evt?.date?._d) {
+      this.policyForm.policyDueDate = evt?.date?._d;
+    }
+    this.datePicker.api.close();
+  }
+  editPolicyFromDocuments() {
+    this.mode = 'EDIT';
+    this.shiftToEditMode.emit();
+    this.pickerChanged.emit(false);
+    this.showCreateDocuments = false;
+    this.navigateToDocumentsSection = true;
+    this.editPolicy();
+  }
+
+  checkForCreateDocuments() {
+    const data = localStorage.getItem('showCreateDocuments');
+    this.navigateToDocumentsSection = data === 'true' ? true : false;
+    if (this.navigateToDocumentsSection) {
+      this.pickerChanged.emit(true);
+      this.showCreateDocuments = true;
+      localStorage.removeItem('showCreateDocuments');
+    }
+  }
+
+  editPolicy() {
+    this.mode = 'EDIT';
+
+    if (this.policyId) {
+      this.policyService.editPolicy(this.policyId).subscribe(
+        (res: any) => {
+          const data = res[0];
+          const categoryIds = data.category_details_arr.map(
+            (id: any) => id.catObjId
+          );
+          this.policyApprovalFlag = data.policyApprovalFlag;
+          this.approvalWorkflowIds = data?.approvalWorkflowDetails?.map(
+            (workflow: any) => workflow?._id
+          );
+          this.selectedWorkflow = [];
+          this.defaultEditApprovers = data?.approvers;
+          this.getApproverWorkFlow(categoryIds, data);
+
+          this.populatePolicyForm(data, categoryIds);
+          this.frequencyDataPopulation(data);
+          this.reviewerFrequencyDataPopulation(data);
+          this.populatePolicyAccessDetails(data);
+        },
+        (error) => {
+          console.error(error);
+        }
+      );
+    }
+  }
+
+  populatePolicyForm(data: any, categoryIds: any) {
+    const reviewerFiles = data.ReviewerAttachments.map((file: any) => {
+      file.filename = file.name;
+      file.filepath = file.file_path;
+      file.original_filename = file.org_name;
+      file.file_name = file.org_name;
+      file.linkSet = '';
+      delete file.name;
+      delete file.file_path;
+      delete file.org_name;
+
+      return file;
+    });
+    const attestationFiles = data.associated_documents.map((ele: any) => {
+      ele.filename = ele.name;
+      ele.filepath = ele.file_path;
+      ele.original_filename = ele.original_file_name;
+      ele.file_name = ele.original_file_name;
+      ele.linkSet = ele.isLinkSet;
+      ele.others = ele?.other_type;
+
+      delete ele.name;
+      delete ele.file_path;
+      delete ele.original_file_name;
+      delete ele.isLinkSet;
+      delete ele?.other_type;
+      return ele;
+    });
+    const group_employeeIds = data.group_employeeNames.map(
+      (id: any) => id?.my_member_id
+    );
+    const group_Ids = data?.usergroup_ids?.map((id: any) => id) ?? [];
+
+    this.policyForm.selectedCategories = this.setList(
+      this.categoryList,
+      categoryIds,
+      '_id'
+    );
+    this.policyForm.policy_id = data?.policy_id;
+    (this.policyForm.policyName = data.policy_name),
+      (this.policyForm.policyNotes = data.notes),
+      (this.policyForm.customTags = data.custom_tags ? data.custom_tags : []);
+
+    this.policyForm.selectedAssignees =
+      group_employeeIds.length > 0
+        ? this.setList(this.assigneesList, group_employeeIds, 'my_member_id')
+        : []; //doubt in name
+
+    this.policyForm.selectedGroupAssignee =
+      group_Ids?.length > 0
+        ? this.setList(this.groupsList, group_Ids, '_id')
+        : [];
+
+    this.policyForm.selectedRCs = data.entities
+      ? this.setList(this.rcList, data.entities.split(','), 'item_id')
+      : [];
+    this.policyForm.CCFailEmail = data.CCFailEmail
+      ? this.setList(this.overseersList, data.CCFailEmail, 'employee_email')
+      : [];
+    this.policyForm.CCFailEmailGroup =
+      data?.cc_fail_usergroup_ids?.length > 0
+        ? this.setList(
+            this.overseerGroupsList,
+            data?.cc_fail_usergroup_ids,
+            '_id'
+          )
+        : [];
+    this.policyForm.CCEmail = data.CCEmail
+      ? this.setList(
+          this.overseersList,
+          data.CCEmail.split(','),
+          'employee_email'
+        )
+      : [];
+    this.policyForm.CCGroupEmail =
+      data?.cc_usergroup_ids?.length > 0
+        ? this.setList(this.overseerGroupsList, data?.cc_usergroup_ids, '_id')
+        : [];
+    this.policyForm.availableOnPortal = data.enablePortal ? true : false;
+    this.policyForm.acceptSuggestions = data.enableSuggestion ? true : false;
+    this.policyForm.requiresSignatureForAttestation = data.is_signature_required
+      ? true
+      : false;
+    this.policyForm.riskRating = data.risk_class ? Number(data.risk_class) : 1;
+    this.policyForm.associatedDocuments = data.associated_documents
+      ? {
+          formatFiles: attestationFiles,
+        }
+      : { formatFiles: [] };
+    this.policyForm.policyDueDate = data.startDate
+      ? moment(data.startDate)
+      : moment();
+    this.policyForm.checkpointDetails = data.checkpoints
+      ? data.checkpoints
+      : [];
+    this.policyForm.totalQuestion = data.total_marks ? data.total_marks : 0;
+    this.policyForm.passingMarks = data.pass_marks ? data.pass_marks : 0;
+    this.policyForm.documentsAndLinks = data.ReviewerAttachments
+      ? {
+          formatFiles: reviewerFiles,
+          formatLinks: data.ReviewerLinks,
+        }
+      : { formatFiles: [], formatLinks: [] };
+    this.policyForm.addResponsibilityCenters =
+      this.policyForm.selectedRCs.length > 0 ? true : false;
+    this.policyForm.addReviewers = data.ReviewerMemberId ? true : false;
+    this.policyForm.addCheckpoints =
+      this.policyForm.checkpointDetails.length > 0 ? true : false;
+    this.policyForm.addOverseers =
+      this.policyForm?.CCFailEmail?.length > 0 ||
+      this.policyForm?.CCEmail?.length > 0 ||
+      this.policyForm?.CCFailEmailGroup?.length > 0 ||
+      this.policyForm?.CCGroupEmail?.length > 0
+        ? true
+        : false;
+    this.policyForm.addAssociatedDocuments =
+      data.associated_documents.length > 0 ? true : false;
+    this.ccEmailObjIds =
+      data?.cc_usergroup_ids?.length > 0 ? data?.cc_usergroup_ids : [];
+    this.ccFailGroupObjIds =
+      data?.cc_fail_usergroup_ids?.length > 0
+        ? data?.cc_fail_usergroup_ids
+        : [];
+    this.policyForm.assessment = data?.assessment ?? [];
+    this.policyForm.addLinkAssessment = data?.assessment?.length;
+    this.policyForm.addVersion = data?.policy_version ? true : false;
+    // this.checkForCreateDocuments();
+    this.policyForm.policy_version = data.policy_version;
+    this.policyForm.programSelectedValues.program =
+      data?.programCatDetails && data?.programCatDetails?.length
+        ? data?.programCatDetails[0]
+        : {};
+    this.selectedLinkProgram =
+      data?.programCatDetails && data?.programCatDetails?.length
+        ? JSON.parse(JSON.stringify(data?.programCatDetails[0]))
+        : {};
+    this.populateOptionalFields();
+    this.loader = false;
+  }
+  changeName(event: string) {
+    let text = event;
+    text = text.replace(/<(.*?)>/gi, '');
+    return text;
+  }
+
+  typeSelected(event: boolean) {
+    this.policyForm.addReviewers = event;
+  }
+  onVersion(event: any) {
+    const regexMatch = new RegExp('^[A-Za-z0-9\\.-]*$');
+    this.isVersionValid = regexMatch.test(this.policyForm.policy_version);
+    if (!this.isVersionValid) {
+      if (this.policyForm.policy_version?.length > 20) {
+        this.versionErrorMessage =
+          'Your input is invalid. The version field can only include numbers, alphabets, hyphen or dots. The maximum character limit is 20 characters.';
+      }
+    } else if (
+      this.isVersionValid &&
+      this.policyForm.policy_version?.length > 20
+    ) {
+      this.versionErrorMessage =
+        'Your input is invalid. The maximum character limit is 20 characters.';
+    }
+  }
+
+  //this function responsible when we click on div select
+  clickApprovalWorkflow(event: boolean) {
+    this.enableApprovalWorkflow = event;
+    this.createApprovalClick = false;
+    this.activateSelector('approvers', true);
+  }
+
+  listCancelClicked(event: any) {
+    if (event) {
+      this.enableApprovalWorkflow = false;
+      this.disableSelector();
+      // this.pickerChanged.emit(false);
+    }
+  }
+
+  selectedApprovalWorkflow(event: any) {
+    this.selectedWorkflow = [event];
+    this.approvalWorkflowIds = event?._id ? [event?._id] : [];
+    this.enableApprovalWorkflow = false;
+    this.policyForm.selectedApprovers = [event];
+    this.disableSelector();
+  }
+
+  updatedProgramDetails(event: any) {
+    this.policyForm.linkProgram = event?.linkProgram;
+    this.policyForm.programSelectedValues = event?.selectedValues;
+    this.policyForm.businessCycle = event?.businessCycle;
+    this.disableSelector();
+  }
+
+  onAssessmentSelect(event: any) {
+    this.policyForm.assessment = [event];
+  }
+  getAssessmentDetails(assessmentDetails: any, type?: string) {
+    this.responsibilityService
+      .getAssessmentDetailsByID(assessmentDetails.assessment_id)
+      .subscribe((res: any) => {
+        if (res?.length > 0) {
+          const categoryDetails = res[0].category.find(
+            (ele: any) => ele._id == assessmentDetails.category_id
+          );
+
+          this.policyForm.assessment = [
+            {
+              category_id: assessmentDetails.category_id,
+              assessment_id: assessmentDetails.assessment_id,
+              assessmentDetails: {
+                id: assessmentDetails.assessment_id,
+                assessment_name: res[0].assessment_name,
+                questions: res[0].questionsCount,
+              },
+              category_details: categoryDetails,
+            },
+          ];
+        }
+      });
+  }
+
+  setOwnersOnLoad() {
+    this.policyForm.policy_owners = this.setList(
+      this.allApprovers,
+      [this.authService.getMemberId()],
+      'member_id'
+    );
+  }
+
+  approvalWorkflowAPICall(event: any) {
+    if (event) {
+      const objectIds = this.returnIds(
+        this.policyForm.selectedCategories,
+        '_id'
+      );
+      this.getApproverWorkFlow(objectIds);
+      this.enableApprovalWorkflow = true;
+    }
+  }
+
+  convertApprovalWorkflow(approverList: any) {
+    let returnJson: any = {};
+    const modifiedData = JSON.parse(JSON.stringify(approverList));
+    modifiedData?.forEach((workflow: any) => {
+      workflow?.approval_workflow?.forEach((approver: any, index: number) => {
+        let i = index + 1;
+        returnJson['level' + i] = approver;
+      });
+    });
+    return returnJson;
+  }
+
+  deleteLevel(index: any) {
+    // Approver Level delete
+    this.selectedWorkflow[0]?.approval_workflow.splice(index, 1);
+    for (
+      let i = index;
+      i < this.selectedWorkflow[0]?.approval_workflow.length;
+      i++
+    ) {
+      if (
+        this.selectedWorkflow[0].approval_workflow[index]['level1'] ===
+        this.selectedWorkflow[0]?.approval_workflow[index]['alias_name']
+      ) {
+        this.selectedWorkflow[0].approval_workflow[index][
+          'alias_name'
+        ] = `Level ${i + 1}`;
+      }
+      this.selectedWorkflow[0].approval_workflow[index]['level1'] = `Level ${
+        i + 1
+      }`;
+    }
+  }
+
+  editWorkflow(event: any) {
+    this.enableApprovalWorkflow = true;
+    this.editApprovalWorkflow = event;
+    this.createApprovalClick = false;
+    this.activateSelector('approvers', true);
+  }
+
+  //Function responsible when we click on CREATE A NEW APPROVAL WORKFLOW
+  createApprovalWorkflow() {
+    this.enableApprovalWorkflow = true;
+    this.createApprovalClick = true;
+  }
+
+  closeClickedCreateForm() {
+    this.enableApprovalWorkflow = false;
+    this.disableSelector();
+  }
+
+  editLevelClicked(editLevel: any, index: any) {
+    this.enableApprovalWorkflow = true;
+    this.editWorkflowLevel = {
+      editLevel: editLevel,
+      index: index,
+    };
+    this.activateSelector('approvers', true);
+  }
+
+  setAccessField(event: number) {
+    this.policyForm.policy_access_type = event;
+    if (event == 0) {
+      // this.policyForm.policy_access_owners = this.usersAccessList;
+      this.saveSelectedList('policyAccess', {
+        users: this.usersAccessList,
+        groups: [],
+      });
+    }
+  }
+
+  getUsersAccessListByCategory(categoryDetails: any) {
+    let uniqueUsers: any = [];
+    let uniqueGroupsId: any = [];
+    uniqueUsers = uniqBy(
+      categoryDetails?.all_managers?.concat(
+        categoryDetails?.all_approvers,
+        categoryDetails?.all_authors
+      ),
+      'member_id'
+    );
+    this.usersAccessList = uniqueUsers;
+    this.usersAccessListIds = this.returnIds(this.usersAccessList, 'member_id');
+
+    uniqueGroupsId = [
+      ...new Set(
+        categoryDetails?.author_usergroup_ids?.concat(
+          categoryDetails?.owner_usergroup_ids
+        )
+      ),
+    ];
+    this.groupsAccessList = this.setList(
+      this.overseerGroupsList,
+      uniqueGroupsId,
+      '_id'
+    );
+    this.groupsAccessListIds = this.returnIds(
+      this.groupsAccessList,
+      'group_id'
+    );
+  }
+
+  populatePolicyAccessDetails(policyDetails: any) {
+    this.policyForm.policy_access_type = policyDetails?.policy_access_type;
+    if (policyDetails?.policy_access_owners?.length) {
+      this.policyForm.policy_access_owners = this.setList(
+        this.usersList,
+        policyDetails?.policy_access_owners,
+        'member_id'
+      );
+    }
+    if (policyDetails?.policy_access_groups?.length) {
+      this.policyForm.policy_access_groups = this.setList(
+        this.overseerGroupsList,
+        policyDetails?.policy_access_groups,
+        '_id'
+      );
+    }
+  }
+
+  resetPolicyAccessDetails() {
+    if (this.policyForm.policy_access_type == 0) {
+      this.policyForm.policy_access_owners = [];
+      this.policyForm.policy_access_groups = [];
+    }
+  }
+}