vcomply-workflow-engine 2.0.4 → 2.0.167

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

@@ -0,0 +1,1778 @@
+import {
+  Component,
+  Input,
+  EventEmitter,
+  OnInit,
+  Optional,
+  Output,
+} from '@angular/core';
+import { cloneDeep } from 'lodash';
+import { EditorConfig } from 'vcomply-editor';
+import { Configurations } from '../configurations';
+import { CategoryList } from '../interfaces/categoryList';
+import { ConfirmationAlert } from '../interfaces/confirmation-alert';
+import { FrequencyService } from '../sharedComponents/frequency/frequency.service';
+import { SnackBarService } from '../ui-kit/snack-bar/snack-bar.service';
+import { AddRiskService } from '../workflow-services/add-risk.service';
+import { AuthService } from '../workflow-services/auth.service';
+import { UiKitService } from '../workflow-services/ui-kit.service';
+import moment from 'moment/moment';
+import {
+  GRC_TYPE_ARRAY,
+  OTHER_GRC_CARD,
+} from '../workflow/shared/constants/grcObject.constant';
+import { GrcService } from '../workflow/shared/services/grc.service';
+import { Subscription } from 'rxjs';
+
+@Component({
+  selector: 'app-workflow-risk',
+  templateUrl: './workflow-risk.component.html',
+  styleUrls: ['./workflow-risk.component.less', '../forms.less'],
+})
+export class WorkflowRiskComponent implements OnInit {
+  GRC_TYPE_ARRAY = GRC_TYPE_ARRAY;
+  responsibilityCentersList: any = [];
+  selectedResponsibilityCenters: any = [];
+  mitigationDetails: any = [];
+  ownersList: any = [];
+  nonRemovableUsersList: any = [];
+  editDetails!: any;
+  smileyMessage = `You're All Set!`;
+  riskData!: any;
+  actionButtons = [
+    { buttonText: 'Add More Risks', class: 'white-btn', id: 'addMore' },
+    { buttonText: 'View Risk', class: 'blue-btn', id: 'viewRisks' },
+  ];
+  sideSelectorElements: any = [
+    'rc',
+    'owner',
+    'overseer',
+    'category',
+    'frequency',
+  ];
+  showSmiley = false;
+  @Input() feature!: any;
+  @Input() mode = 'EDIT';
+  @Input() riskId = '';
+  @Input() defaultRiskType = 'NORMAL';
+  @Input() moveToRegisterMode = '';
+  @Input() secondaryOpenPortal = '';
+  @Output() showConfirmationAlert = new EventEmitter();
+  @Output() pickerChanged = new EventEmitter();
+  @Output() populateOption = new EventEmitter();
+  @Output() closeWorkflow = new EventEmitter();
+  @Output() disconnectRefresh = new EventEmitter();
+  @Output() refreshForm = new EventEmitter();
+  @Output() hideElementsFromMoreOptions = new EventEmitter();
+  @Output() rcSelected = new EventEmitter();
+  @Input() openedFrom = '';
+  scrollToBottom = false;
+  categoryList: CategoryList = {
+    strategic: {
+      name: 'STRATEGIC',
+      data: [],
+    },
+    operational: {
+      name: 'OPERATIONAL',
+      data: [],
+    },
+    compliance: {
+      name: 'COMPLIANCE',
+      data: [],
+    },
+    others: {
+      name: 'OTHERS',
+      data: [],
+    },
+  };
+  overseersList: any = [];
+  overseersGroupList: any = [];
+  adminsList: any = [];
+  overseersIdList: any = [];
+  timezone!: string;
+  date!: Date;
+  riskNameFocus = false;
+  assessmentFocus = false;
+  riskTypeChangeAllowed = false;
+  riskForm: any = {
+    riskType: 'NORMAL',
+    title: '',
+    description: '',
+    responsibilityCentersList: [],
+    ownersList: [],
+    groupsList: [],
+    category: {
+      type: 'strategic',
+      selectedCategory: '',
+    },
+    categoryCustomTags: [],
+    overseersList: [],
+    overseersGroupList: [],
+    mitigation: 0,
+    assessment_deadline_days: 0,
+    head_ids: [],
+    addOverseer: false,
+    addMitigation: false,
+    addMitigationPlan: false,
+    mitigationDescriptionPlan: '',
+    frequency_details: {
+      frequency: '',
+      started_at: '',
+      frequency_time: '',
+      remind_before_days: 0,
+    },
+    addRiskLabel: false,
+    riskLabelValue: 1,
+    enableAllFutureBusinessCycle: true,
+    GRC: false,
+    selectedGRCObjects: [],
+  };
+  apiUrl = '';
+  memberId = 0;
+  organizationId = 0;
+
+  usersListLoaded = false;
+  adminsListLoaded = false;
+  categoryListLoaded = false;
+  rcListLoaded = false;
+  submitted = false;
+  frequencyDetails = {
+    frequency: '',
+    started_at: '',
+    frequency_time: '',
+    remind_before_days: 0,
+    failed_after_days: 0,
+    can_assess_before_days: 0,
+  };
+  frequencyPlaceholder = 'Set a Reassessment Frequency';
+  shortMonth: Array<string> = [];
+  settingsInfo!: any;
+  loader = false;
+  activeSelector = '';
+  currentTimeStamp = Math.round(Date.now() / 1000);
+  featureflag_groups: boolean = false;
+  groupsList: any = [];
+  otherGRCCard = JSON.parse(JSON.stringify(OTHER_GRC_CARD));
+
+  /* Creating an array for risk label with it's value. */
+  riskLabelList: any = [
+    { name: 'Newly Identified Risk', value: 1 },
+    { name: 'Rapidly Changing Risk', value: 2 },
+  ];
+  otherGRCSubscription!: Subscription;
+  grcList: any;
+  grcLoader: boolean = false;
+  selectedGRCTab: number = 0;
+  grcDataWithTypes: any = {
+    assets: [],
+    processes: [],
+    vendors: [],
+    inventory: [],
+  };
+  grcSearchString: string = '';
+  grcTabLoader: boolean = false;
+
+  constructor(
+    private riskService: AddRiskService,
+    private authService: AuthService,
+    private uiKitService: UiKitService,
+    private snackBar: SnackBarService,
+    private frequencyService: FrequencyService,
+    private grcService: GrcService,
+    @Optional() config?: Configurations
+  ) {
+    this.timezone = this.authService.getUserTimeZone();
+  }
+
+  description: EditorConfig = {
+    mode: 'prime',
+    colorPalette: true,
+    link: true,
+    placeholder: 'Add a description for this risk',
+  };
+
+  mitigationDescriptionPlan: EditorConfig = {
+    mode: 'prime',
+    colorPalette: true,
+    link: true,
+    placeholder: 'Describe the recommended mitigation plans',
+  };
+
+  ngOnInit(): void {
+    this.featureflag_groups = this.feature.isFeatureEnabled('ff_risk_groups');
+    this.pickerChanged.emit(false);
+    this.loader = true;
+    this.uiKitService.isLoader = true;
+    this.getAdminsList();
+    this.getRCList();
+    this.getOwnersList();
+    if (this.featureflag_groups) {
+      this.getGroupList();
+    }
+    this.getCategoryList();
+    this.getSettingsInfo();
+
+    this.shortMonth = this.frequencyService.monthArray.map((month) =>
+      month.substring(0, 3)
+    );
+    if (this.mode === 'CREATE') {
+      this.organizationId = this.authService.getOrganizationId();
+    }
+    this.memberId = this.authService.getMemberId();
+    if (this.secondaryOpenPortal !== 'OTHER' && this.mode !== 'EDIT') {
+      this.nonRemovableUsersList.push(this.memberId);
+    }
+    this.checkWhetherAllListsLoaded();
+    if (this.openedFrom === 'REPORTED_RISK') {
+      this.riskForm.riskType = 'REPORTED';
+      this.riskTypeChangeAllowed = false;
+    } else if (this.openedFrom === 'MOVE_TO_REGISTER') {
+      this.riskForm.riskType = 'NORMAL';
+      this.riskTypeChangeAllowed = false;
+    } else {
+      this.setRiskTypeBasedOnSubscription();
+    }
+  }
+
+  //TO get groupList data
+  getGroupList() {
+    this.riskService.getGroupsList().subscribe(
+      (res: any) => {
+        this.groupsList = res?.data;
+      },
+      (err) => {
+        console.error(err);
+      }
+    );
+  }
+
+  setRiskTypeBasedOnSubscription() {
+    if (this.openedFrom === 'REPORTED_RISK') {
+      this.riskForm.riskType = 'REPORTED';
+    }
+    this.authService.getUserInfo().subscribe({
+      next: (res: any) => {
+        if (res && res?.permission) {
+          const permission = JSON.parse(res?.permission);
+          if (this.authService?.isAdmin() || this.authService?.isKeyAdmin()) {
+            this.riskTypeChangeAllowed = true;
+          } else if (this.authService.isManager()) {
+            if (permission?.MRISK === 1) {
+              this.riskTypeChangeAllowed = true;
+            } else {
+              this.riskTypeChangeAllowed = false;
+              this.riskForm.riskType = 'REPORTED';
+            }
+          } else if (this.authService.isUser()) {
+            this.riskTypeChangeAllowed = false;
+            this.riskForm.riskType = 'REPORTED';
+          }
+        } else {
+          this.riskTypeChangeAllowed = false;
+          this.riskForm.riskType = 'REPORTED';
+        }
+
+        if (res && res?.roleActions) {
+          const moduleIndex = res.roleActions.findIndex(
+            (element: any) => element.moduleName == 'risk'
+          );
+          const riskPermissions =
+            res.roleActions[moduleIndex].subModule[1].permissions;
+          riskPermissions.forEach((permission: any) => {
+            if (permission.name == 'manage risks' && permission.enable) {
+              this.riskTypeChangeAllowed = true;
+              this.riskForm.riskType = 'NORMAL';
+            }
+          });
+        }
+        if (this.mode === 'EDIT') {
+          this.riskForm.riskType = 'NORMAL';
+          this.riskTypeChangeAllowed = false;
+        }
+      },
+    });
+  }
+
+  changeRisk(type: string) {
+    this.riskForm = { ...this.riskForm, ...{ riskType: type } };
+    this.setPopupButtons();
+    if (type === 'REPORTED') {
+      this.riskForm.assessment_deadline_days = 0;
+    }
+  }
+
+  getCurrentlyLoggedInUser() {
+    if (this.mode === 'EDIT') {
+      const ownersList = this.setList(
+        this.ownersList,
+        this.editDetails?.owner,
+        'member_id'
+      )?.map((ele: any) => ele?.member_id);
+      if (ownersList.includes(this.memberId)) {
+        return [this.authService.getMemberId()];
+      } else {
+        return [];
+      }
+    } else {
+      return [this.authService.getMemberId()];
+    }
+  }
+
+  setPopupButtons() {
+    if (this.riskForm.riskType === 'REPORTED') {
+      this.actionButtons = [
+        { buttonText: 'Add More Risks', class: 'white-btn', id: 'addMore' },
+        {
+          buttonText: 'View Reported Risks',
+          class: 'blue-btn',
+          id: 'manageReportedRisk',
+        },
+      ];
+    } else {
+      this.actionButtons = [
+        { buttonText: 'Add More Risks', class: 'white-btn', id: 'addMore' },
+        { buttonText: 'View Risk', class: 'blue-btn', id: 'viewRisks' },
+      ];
+    }
+  }
+  getRiskDetails(riskId: any) {
+    this.riskService.getRiskDetail(riskId).subscribe(
+      (res: any) => {
+        this.loader = false;
+        this.uiKitService.isLoader = false;
+        this.editDetails = cloneDeep(res);
+        this.riskForm.title = res.title;
+        if (this.openedFrom === 'MOVE_TO_REGISTER') {
+          this.riskForm.riskType = 'NORMAL';
+          this.riskTypeChangeAllowed = false;
+        } else {
+          this.riskForm.riskType = res?.risk_type ?? 'REPORTED';
+        }
+
+        this.riskForm.description = res.description;
+        this.riskForm.responsibilityCentersList = this.setList(
+          this.responsibilityCentersList,
+          res.rc_id,
+          'item_id'
+        );
+        this.riskForm.ownersList = this.setList(
+          this.ownersList,
+          res.owner,
+          'member_id'
+        );
+        this.riskForm.groupsList = this.setList(
+          this.groupsList,
+          res?.usergroup_ids,
+          '_id'
+        );
+        this.riskForm.mitigationDescriptionPlan = res.mitigationDescriptionPlan;
+        const type = this.setCategoryType(res.category_type[0]);
+        const categoryIndex = this.categoryList[type]?.data?.findIndex(
+          (element: any) => element.category_id == res.category[0]
+        );
+        if (categoryIndex != -1) {
+          this.riskForm.category = {
+            type,
+            selectedCategory: this.categoryList[type]?.data[categoryIndex],
+          };
+          this.riskForm.categoryCustomTags = res.category_custom_tag;
+        }
+
+        this.riskForm.overseersList = this.setList(
+          this.ownersList,
+          res.manage_oversight,
+          'member_id'
+        );
+        this.riskForm.overseersGroupList = this.setList(
+          this.groupsList,
+          res?.overseergroup_ids,
+          '_id'
+        );
+        this.riskForm.mitigation = res?.mitigation
+          ? res?.mitigation
+          : this.riskForm?.mitigation;
+        this.riskForm.assessment_deadline_days = res.assessment_deadline_days;
+        this.riskForm.addOverseer =
+          res.manage_oversight.length > 0 || res?.overseergroup_ids?.length > 0
+            ? true
+            : false;
+        this.riskForm.addMitigation = res.mitigation ? true : false;
+        this.organizationId = res.organisation_id;
+        this.riskForm.head_ids = res?.head_ids ? res?.head_ids : [];
+        this.riskForm.mitigationDescriptionPlan =
+          res?.mitigation_plan_recommendation ?? '';
+        this.riskForm.addMitigationPlan =
+          res?.mitigation_plan_recommendation.trim()?.length ? true : false;
+        this.riskForm.addRiskLabel = res.risk_label ? true : false;
+        if (res.assessment_date_timestamp) {
+          this.date = new Date(res.assessment_date);
+        }
+        if (res.IfAssessmentDone > 0) {
+          res.all_owner_arr.forEach((element: any) => {
+            if (element.assessment_done > 0) {
+              this.nonRemovableUsersList.push(element.member_id);
+            }
+          });
+        }
+        if (this.secondaryOpenPortal === 'OTHER' && this.mode === 'EDIT') {
+          this.nonRemovableUsersList = Array.from(
+            new Set<any[]>([...this.nonRemovableUsersList, ...res?.owner])
+          );
+        }
+        if (this.secondaryOpenPortal !== 'OTHER' && this.mode === 'EDIT') {
+          this.nonRemovableUsersList = Array.from(
+            new Set<any[]>([
+              ...this.nonRemovableUsersList,
+              ...this.getCurrentlyLoggedInUser(),
+            ])
+          );
+        }
+        if (res?.risk_type === 'NORMAL') {
+          this.nonRemovableUsersList = Array.from(
+            new Set<any[]>([
+              ...this.nonRemovableUsersList,
+              ...this.getCurrentlyLoggedInUser(),
+            ])
+          );
+        }
+        this.rcSelected.emit(1);
+        this.saveSelectedList(res.linkedGrcDetails);
+        this.getOtherGRCTabCount({ rc_ids: '' });
+        this.getOtherGRCObjects({ rc_ids: '' });
+        this.riskForm.enableAllFutureBusinessCycle =
+          res?.future_businesscycle_visibility;
+        this.populateOptionalFields();
+        this.frequencyDataPopulate(res?.frequency_details);
+        this.riskForm.frequency_details = res?.frequency_details;
+        this.getFrequencyPlaceholder(res.frequency_details);
+        this.setOverseersList();
+      },
+      (err) => {
+        console.log(err);
+        this.loader = false;
+        this.uiKitService.isLoader = false;
+      }
+    );
+  }
+
+  populateOptionalFields() {
+    const activatedOptions = [];
+    if (this.riskForm.addMitigation) {
+      activatedOptions.push('MITIGATION');
+    }
+    if (this.riskForm.addOverseer) {
+      activatedOptions.push('OVERSEER');
+    }
+    if (this.riskForm.addMitigationPlan) {
+      activatedOptions.push('MITIGATION_PLAN');
+    }
+    if (this.riskForm.addRiskLabel) {
+      activatedOptions.push('RISK_LABEL');
+    }
+
+    if (this.riskForm.selectedGRCObjects?.length) {
+      activatedOptions.push('GRC_OBJECTS');
+      this.riskForm.GRC = true;
+    }
+    this.populateOption.emit(activatedOptions);
+  }
+
+  setCategoryType(type: any) {
+    if (type === 1) {
+      return 'strategic';
+    } else if (type === 2) {
+      return 'operational';
+    } else if (type === 3) {
+      return 'compliance';
+    } else if (type === 0) {
+      return 'others';
+    } else {
+      return 'strategic';
+    }
+  }
+
+  getRCList() {
+    const rcArray: any[] = [];
+    this.riskService
+      .getResponsibilityCenterList(
+        rcArray,
+        this.mode === 'EDIT' ? this.riskId : ''
+      )
+      .subscribe(
+        (res) => {
+          this.responsibilityCentersList = res;
+          this.rcListLoaded = true;
+        },
+        (err) => {
+          console.error(err);
+          this.rcListLoaded = true;
+        }
+      );
+  }
+
+  getCategoryList() {
+    this.riskService.getCategoryList().subscribe(
+      (res: any) => {
+        this.categoryList.strategic.data = res.strategic_arr;
+        this.categoryList.operational.data = res.operational_arr;
+        this.categoryList.compliance.data = res.compliance_arr;
+        this.categoryList.others.data = res.others_arr;
+        this.categoryListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.categoryListLoaded = true;
+      }
+    );
+  }
+
+  getOwnersList() {
+    this.riskService.getOrganizationUsers().subscribe(
+      (res: any) => {
+        this.ownersList = res;
+
+        this.usersListLoaded = true;
+        const index: number = res.findIndex(
+          (user: any) => user.member_id === this.memberId
+        );
+        if (index !== -1) {
+          if (this.secondaryOpenPortal !== 'OTHER' && this.mode !== 'EDIT') {
+            this.riskForm.ownersList.push(res[index]);
+          }
+        }
+      },
+      (err) => {
+        console.error(err);
+        this.usersListLoaded = true;
+      }
+    );
+  }
+  getAdminsList() {
+    this.riskService.getAdminKeyAdminList().subscribe(
+      (res) => {
+        this.adminsList = res;
+        this.adminsListLoaded = true;
+      },
+      (err) => {
+        console.error(err);
+        this.adminsListLoaded = true;
+      }
+    );
+  }
+
+  getSettingsInfo() {
+    this.riskService.getRiskSettingDetails().subscribe(
+      (res) => {
+        this.settingsInfo = res;
+        this.hideOptionalFields(res);
+        this.mitigationDetails = res?.risk_mitigation_priority?.mitigation_data;
+        let defaultMitigation = this.mitigationDetails?.filter(
+          (ele: any) => ele?.mitigation_name === 'LOW'
+        );
+        if (defaultMitigation?.length) {
+          this.riskForm.mitigation = defaultMitigation[0]?.mitigation_id;
+        }
+      },
+      (err) => {
+        console.error(err);
+      }
+    );
+  }
+
+  hideOptionalFields(res: any) {
+    if (res?.risk_automation_enable === 1) {
+      this.hideElementsFromMoreOptions.emit(['MITIGATION']);
+    }
+  }
+
+  checkWhetherAllListsLoaded() {
+    if (
+      this.rcListLoaded &&
+      this.usersListLoaded &&
+      this.adminsListLoaded &&
+      this.categoryListLoaded
+    ) {
+      this.setOverseersList();
+      if (this.mode === 'EDIT') {
+        this.getRiskDetails(this.riskId);
+      } else {
+        this.loader = false;
+        this.uiKitService.isLoader = false;
+      }
+    } else {
+      setTimeout(() => {
+        this.checkWhetherAllListsLoaded();
+      }, 300);
+    }
+  }
+
+  setOverseersList() {
+    let ids: any = [];
+    let rcOwnerIds: any = [];
+    const users = cloneDeep(this.riskForm.ownersList);
+    const responsibilityCenters = cloneDeep(
+      this.riskForm.responsibilityCentersList
+    );
+    const admins = cloneDeep(this.adminsList);
+    const allUsers = cloneDeep(this.ownersList);
+    users.forEach((user: any) => {
+      ids.push(user.member_id);
+    });
+    admins.forEach((user: any) => {
+      ids.push(user.member_id);
+    });
+    responsibilityCenters.forEach((rc: any) => {
+      const ary = [...rc.owner, ...rc.parent_owners];
+      ids = [...ids, ...ary];
+      rcOwnerIds = [...rcOwnerIds, ...ary];
+    });
+
+    ids = [...new Set(ids)];
+    rcOwnerIds = [...new Set(rcOwnerIds)];
+    this.riskForm.head_ids = rcOwnerIds;
+    this.overseersList = allUsers.filter(
+      (user: any) => !ids.includes(user.member_id)
+    );
+    this.riskForm.overseersList = this.riskForm.overseersList.filter(
+      (user: any) => !ids.includes(user.member_id)
+    );
+    //Groups which are selected in Owners field should not be visible Overseer
+    let groupids: any = [];
+    const groups = cloneDeep(this.riskForm.groupsList);
+    const allgroups = cloneDeep(this.groupsList);
+    groups.forEach((group: any) => {
+      groupids.push(group.group_id);
+    });
+    groupids = [...new Set(groupids)];
+    this.overseersGroupList = allgroups.filter(
+      (group: any) => !groupids.includes(group.group_id)
+    );
+    this.riskForm.overseersGroupList = this.riskForm.overseersGroupList.filter(
+      (user: any) => !groupids.includes(user.group_id)
+    );
+  }
+
+  activateSelector(type: any, event: boolean) {
+    this.activeSelector = event ? type : '';
+    if (
+      ['rc', 'owner', 'overseer', 'category', 'frequency', 'GRC'].includes(type)
+    ) {
+      this.pickerChanged.emit(event);
+    }
+    if (type === 'GRC' && event) {
+      this.grcSearchString = '';
+      this.getOtherGRCObjects();
+      this.getOtherGRCTabCount({ rc_ids: '' });
+    }
+  }
+
+  activeDeselector() {
+    this.activeSelector = '';
+    this.pickerChanged.emit(false);
+  }
+
+  remove(type: any, event: any, index?: number) {
+    switch (type) {
+      case 'rc':
+        const rcIndex = this.riskForm.responsibilityCentersList.findIndex(
+          (rc: any) => rc.rc_id == event.rc_id
+        );
+        this.riskForm.responsibilityCentersList.splice(rcIndex, 1);
+        this.saveSelectedList([]);
+        this.getOtherGRCTabCount({ rc_ids: '' });
+        this.getOtherGRCObjects({ rc_ids: '', type: this.selectedGRCTab });
+        break;
+      case 'owner':
+        const ownerIndex = this.riskForm.ownersList.findIndex(
+          (owner: any) => owner.member_id == event.member_id
+        );
+        this.riskForm.ownersList.splice(ownerIndex, 1);
+        this.setOverseersList();
+        break;
+      case 'Ownergroup':
+        const groupIndex = this.riskForm?.groupsList.findIndex(
+          (owner: any) => owner.group_id == event.group_id
+        );
+        this.riskForm.groupsList.splice(groupIndex, 1);
+        break;
+      case 'overseer':
+        const overseerIndex = this.riskForm.overseersList.findIndex(
+          (overseer: any) => overseer.member_id == event.member_id
+        );
+        this.riskForm.overseersList.splice(overseerIndex, 1);
+        break;
+      case 'overseergroup':
+        const overseergroupIndex = this.riskForm?.overseersGroupList.findIndex(
+          (overseer: any) => overseer.group_id == event.group_id
+        );
+        this.riskForm.overseersGroupList.splice(overseergroupIndex, 1);
+        break;
+      case 'category':
+        this.riskForm.category = {
+          type: 'strategic',
+          selectedCategory: '',
+        };
+        this.riskForm.categoryCustomTags = [];
+        break;
+      case 'GRC':
+        this.removeOtherGRCObjects(event);
+        // this.riskForm.selectedGRCObjects.splice(index, 1);
+        // this.saveSelectedList(this.riskForm.selectedGRCObjects);
+        break;
+    }
+  }
+
+  saveSelectedRCList(rcIds: any) {
+    this.saveSelectedList([]);
+    this.activeDeselector();
+    const selectedRC = this.setList(
+      this.responsibilityCentersList,
+      rcIds,
+      'item_id'
+    );
+    this.rcSelected.emit(selectedRC?.length);
+
+    this.riskForm.responsibilityCentersList = selectedRC;
+    this.getOtherGRCTabCount({ rc_ids: '' });
+    this.getOtherGRCObjects({ rc_ids: '', type: this.selectedGRCTab });
+    this.setOverseersList();
+    this.pickerChanged.emit(false);
+  }
+
+  saveSelectedCategory(category: any) {
+    this.activeDeselector();
+    this.riskForm.category = category;
+    const customTags: any = [];
+    category.selectedCategory.custom_tag.forEach((element: any) => {
+      const tag = {
+        custom_tag_name: element.tagName,
+        custom_tag_value: '',
+      };
+      customTags.push(tag);
+    });
+    this.riskForm.categoryCustomTags = customTags;
+    this.pickerChanged.emit(false);
+  }
+
+  saveSelectedOwnersList(ids: any) {
+    this.activeDeselector();
+    if (this.featureflag_groups) {
+      let ownerids;
+      let groupIds;
+      ownerids = this.returnIds(ids.users, 'member_id');
+      groupIds = this.returnIds(ids.groups, 'group_id');
+      const selectedOwners = this.setList(
+        this.ownersList,
+        ownerids,
+        'member_id'
+      );
+      const selectedGroups = this.setList(
+        this.groupsList,
+        groupIds,
+        'group_id'
+      );
+      this.setList(this.groupsList, groupIds, 'group_id');
+      this.riskForm.ownersList = selectedOwners;
+      this.riskForm.groupsList = selectedGroups;
+    } else {
+      const selectedOwners = this.setList(this.ownersList, ids, 'member_id');
+      this.riskForm.ownersList = selectedOwners;
+    }
+    this.setOverseersList();
+    this.pickerChanged.emit(false);
+  }
+
+  saveSelectedOverseersList(ids: any) {
+    this.activeDeselector();
+    if (!this.featureflag_groups) {
+      const selectedOverseers = this.setList(
+        this.overseersList,
+        ids,
+        'member_id'
+      );
+      this.riskForm.overseersList = selectedOverseers;
+    } else {
+      let overseerids;
+      let overseerGroupIds;
+      overseerids = this.returnIds(ids.users, 'member_id');
+      overseerGroupIds = this.returnIds(ids.groups, 'group_id');
+      const selectedOverseers = this.setList(
+        this.overseersList,
+        overseerids,
+        'member_id'
+      );
+      const selectedOverseerGroups = this.setList(
+        this.overseersGroupList,
+        overseerGroupIds,
+        'group_id'
+      );
+      this.riskForm.overseersList = selectedOverseers;
+      this.riskForm.overseersGroupList = selectedOverseerGroups;
+    }
+    this.pickerChanged.emit(false);
+  }
+
+  changeRiskAssessment(name: string): void {
+    switch (name) {
+      case 'subtract':
+        if (this.riskForm.assessment_deadline_days > 1) {
+          this.riskForm.assessment_deadline_days -= 1;
+          this.setDate(this.riskForm.assessment_deadline_days);
+        }
+        break;
+      case 'add':
+        this.riskForm.assessment_deadline_days += 1;
+        this.setDate(this.riskForm.assessment_deadline_days);
+        break;
+    }
+  }
+
+  setDate(days: number): void {
+    if (days >= 0) {
+      const miliseconds = days * 86400 * 1000;
+      const d: number = new Date(
+        new Date(Date.now()).toLocaleString('en-US', {
+          timeZone: this.timezone,
+        })
+      ).getTime();
+      this.date = new Date(d + miliseconds);
+    }
+  }
+
+  changeRiskAssessmentDeadline(event: number): void {
+    if (!isNaN(event)) {
+      this.setDate(event);
+    }
+  }
+
+  setList(list: any[], ids: any[], key: string) {
+    const data: any = [];
+    list.forEach((element: any) => {
+      if (ids.includes(element[key])) {
+        data.push(element);
+      }
+    });
+    return data;
+  }
+
+  returnIds(list: any[], key: string) {
+    return list.map((ele) => {
+      if (ele[key]) {
+        return ele[key];
+      }
+    });
+  }
+
+  submitRisk() {
+    this.setPopupButtons();
+    const valid = this.validateRisk();
+    if (!valid) {
+      return false;
+    } else if (this.mode === 'EDIT' && this.editDetails.IfAssessmentDone > 0) {
+      const prevRCArr = this.editDetails.rc_id;
+      const currRCArr = this.returnIds(
+        this.riskForm.responsibilityCentersList,
+        'rc_id'
+      );
+      if (
+        prevRCArr.length === currRCArr.length &&
+        prevRCArr
+          .sort()
+          .every((value: any, index: any) => value === currRCArr.sort()[index])
+      ) {
+        this.createRisk(this.riskForm);
+      } else {
+        const confirmationDetails: ConfirmationAlert = {
+          isVisible: true,
+          message: `The Responsibility Center(s) associated with this risk has been modified.
+               Hence, this risk needs to be reassessed. Once you confirm, the current due date will be closed and a new risk assessment due date will be generated.`,
+          action: 'EDIT_RISK',
+        };
+        this.showConfirmationAlert.emit(confirmationDetails);
+      }
+    } else {
+      this.createRisk(this.riskForm);
+    }
+  }
+
+  addMoreInfo(event: any) {
+    switch (event.code) {
+      case 'OVERSEER':
+        this.riskForm.addOverseer = event?.checked;
+        break;
+      case 'MITIGATION':
+        this.riskForm.addMitigation = event?.checked;
+        break;
+      case 'MITIGATION_PLAN':
+        this.riskForm.addMitigationPlan = event?.checked;
+        break;
+      case 'RISK_LABEL':
+        this.riskForm.addRiskLabel = event?.checked;
+        break;
+      case 'GRC_OBJECTS':
+        this.riskForm.GRC = event?.checked;
+        break;
+    }
+    this.scrollToBottom = true;
+  }
+
+  validateRisk() {
+    this.submitted = true;
+    const event = this.riskForm.title;
+    const re = /&nbsp;|<br>/g;
+    this.riskForm.title = event.replace(re, '').trim();
+    // ((!this.settingsInfo.assessment_deadline_enable) && (this.riskForm?.assessment_deadline_days < 1) && this.riskForm?.riskType !== 'REPORTED') ||
+    if (
+      !this.riskForm.title ||
+      this.riskForm.responsibilityCentersList.length == 0 ||
+      this.riskForm.ownersList.length == 0 ||
+      (this.riskForm.riskType === 'REPORTED' &&
+        !this.riskForm?.description?.trim()?.length) ||
+      (this.riskForm?.riskType !== 'REPORTED' &&
+        (!this.riskForm?.frequency_details?.frequency ||
+          this.riskForm?.frequency_details?.frequency === ''))
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  createRisk(riskForm: any) {
+    this.loader = true;
+    this.uiKitService.isLoader = false;
+    const payload: any = {
+      title: riskForm.title,
+      description: riskForm.description,
+      category_custom_tag: riskForm.categoryCustomTags,
+      assessment_deadline_enable: this.settingsInfo.assessment_deadline_enable,
+      owner: this.returnIds(riskForm.ownersList, 'member_id'),
+      category: riskForm.category?.selectedCategory?.category_id
+        ? [riskForm.category.selectedCategory.category_id]
+        : [],
+      manage_oversight: riskForm.addOverseer
+        ? this.returnIds(riskForm.overseersList, 'member_id')
+        : [],
+      rc_id: this.returnIds(riskForm.responsibilityCentersList, 'item_id'),
+      head_ids: riskForm.head_ids,
+      rating_arr: [],
+      member_id: this.memberId,
+      organisation_id: this.organizationId,
+      risk_progress_flag:
+        this.mode === 'EDIT' ? this.editDetails.risk_progress_flag : 1,
+      IfAssessmentDone:
+        this.mode == 'EDIT' ? this.editDetails.IfAssessmentDone : 0,
+      workshop_id: this.mode == 'EDIT' ? this.editDetails.workshop_id : 0,
+      complete_assessment: 0,
+      mitigation: riskForm.addMitigation ? riskForm.mitigation : 0,
+      weightage_enable: this.settingsInfo.weightage_enable,
+      treatment_type: this.settingsInfo.treatment_criteria,
+      weightage_details: this.settingsInfo.weightage_details,
+      weightage_set_by: this.settingsInfo.weightage_set_by,
+      weightage_str: [
+        this.settingsInfo.weightage_details.impact.value,
+        this.settingsInfo.weightage_details.likelihood.value,
+        this.settingsInfo.weightage_details.velocity.value,
+        this.settingsInfo.weightage_details.vulnerability.value,
+      ],
+      assessment_deadline_set_by: this.settingsInfo.assessment_deadline_set_by,
+      // assessment_deadline_days: (this.settingsInfo.assessment_deadline_enable) ? this.settingsInfo.assessment_deadline_days : riskForm.assessment_deadline_days,
+      risk_type: this.riskForm?.riskType ?? 'NORMAL',
+      mitigation_plan_recommendation: this.riskForm?.addMitigationPlan
+        ? this.riskForm?.mitigationDescriptionPlan ?? ''
+        : '',
+      frequency_details: this.riskForm?.frequency_details,
+      risk_label: riskForm?.addRiskLabel ? riskForm?.riskLabelValue : 1,
+      future_businesscycle_visibility:
+        riskForm?.enableAllFutureBusinessCycle ?? true,
+      linked_GRC_ids: this.riskForm.GRC
+        ? this.riskForm.selectedGRCObjects.map((grc: any) => grc?._id)
+        : [],
+    };
+    if (this.featureflag_groups) {
+      payload['usergroup_ids'] = this.returnIds(riskForm.groupsList, '_id');
+      payload['overseergroup_ids'] = riskForm.addOverseer
+        ? this.returnIds(riskForm.overseersGroupList, '_id')
+        : [];
+    }
+    if (this.mode == 'CREATE') {
+      this.riskService.addRisk(payload).subscribe(
+        (res: any) => {
+          this.riskData = res;
+          this.riskId = res._id;
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+          this.showSmiley = true;
+          this.uiKitService.isSmileyOn = true;
+        },
+        (err) => {
+          console.log(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' && this.openedFrom !== 'MOVE_TO_REGISTER') {
+      this.smileyMessage = `The risk has been modified.`;
+      this.riskService.updateRisk(this.riskId, payload).subscribe(
+        (res: any) => {
+          this.riskData = res;
+          this.showSmiley = true;
+          this.uiKitService.isSmileyOn = true;
+          this.loader = false;
+          this.uiKitService.isLoader = false;
+        },
+        (err) => {
+          console.log(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.openedFrom === 'MOVE_TO_REGISTER') {
+      this.closeWorkflow.emit({
+        evt: { action: 'MOVE_TO_REGISTER', payload },
+        confirm: false,
+      });
+    }
+  }
+
+  resetForm() {
+    this.scrollToBottom = false;
+    this.showSmiley = false;
+    this.uiKitService.isSmileyOn = false;
+    this.riskForm = {
+      title: '',
+      description: '',
+      riskType: this.riskForm?.riskType,
+      addMitigationPlan: false,
+      mitigationDescriptionPlan: '',
+      responsibilityCentersList: [],
+      ownersList: [],
+      groupsList: [],
+      category: {
+        type: 'strategic',
+        selectedCategory: '',
+      },
+      categoryCustomTags: [],
+      overseersList: [],
+      mitigation: 0,
+      assessment_deadline_days: 0,
+      head_ids: [],
+      addOverseer: false,
+      addMitigation: false,
+      frequency_details: {
+        frequency: '',
+        started_at: '',
+        frequency_time: '',
+        remind_before_days: 0,
+      },
+      riskLabelValue: 1,
+      addRiskLabel: false,
+      GRC: false,
+      selectedGRCObjects: [],
+      enableAllFutureBusinessCycle: true,
+    };
+    this.nonRemovableUsersList = [];
+    this.organizationId = this.authService.getOrganizationId();
+    this.memberId = this.authService.getMemberId();
+    this.nonRemovableUsersList = this.getCurrentlyLoggedInUser();
+    this.date = new Date();
+    this.submitted = false;
+    this.refreshForm.emit(true);
+    this.rcSelected.emit(false);
+    this.frequencyDetails = {
+      frequency: '',
+      started_at: '',
+      frequency_time: '',
+      remind_before_days: 0,
+      failed_after_days: 0,
+      can_assess_before_days: 0,
+    };
+    this.frequencyPlaceholder = 'Set a Reassessment Frequency';
+
+    this.populateOptionalFields();
+    this.getOwnersList();
+  }
+
+  action(event: string) {
+    switch (event) {
+      case 'addMore':
+        this.resetForm();
+        this.populateOptionalFields();
+        break;
+      case 'viewRisks':
+        this.viewRisks();
+        break;
+      case 'manageReportedRisk':
+        this.redirectToReported();
+        break;
+    }
+  }
+
+  closeSmiley(event: any) {
+    this.showSmiley = false;
+    this.uiKitService.isSmileyOn = false;
+    this.closeWorkflow.emit({ evt: this.riskData, confirm: false });
+  }
+
+  viewRisks(): void {
+    this.disconnectRefresh.emit(false);
+    let url: string;
+    if (window.location.host.startsWith('localhost')) {
+      url = 'http://' + window.location.host;
+    } else {
+      url = 'https://' + window.location.host;
+    }
+
+    if (window.location.host.startsWith('localhost')) {
+      url += '/risk-workroom/' + this.riskId;
+    } else {
+      if (window.location.href.includes('/riskv2')) {
+        url += '/riskv2/risk-workroom/' + this.riskId;
+      } else {
+        url += '/risk/risk-workroom/' + this.riskId;
+      }
+    }
+    window.location.href = url;
+    //this.resetForm();
+  }
+
+  redirectToReported(): void {
+    this.disconnectRefresh.emit(false);
+    let url: string;
+    if (window.location.host.startsWith('localhost')) {
+      url = 'http://' + window.location.host;
+    } else {
+      url = 'https://' + window.location.host;
+    }
+
+    if (window.location.host.startsWith('localhost')) {
+      url += '/reported-risk';
+    } else {
+      if (window.location.href.includes('/riskv2')) {
+        url += '/riskv2/reported-risk';
+      } else {
+        url += '/risk/reported-risk';
+      }
+    }
+    window.location.href = url;
+    //this.resetForm();
+  }
+  checkDescription() {
+    if (this.riskForm.description == '<br>') {
+      this.riskForm.description = '';
+    }
+  }
+
+  checkMitigationPlan() {
+    if (this.riskForm.mitigationDescriptionPlan == '<br>') {
+      this.riskForm.mitigationDescriptionPlan = '';
+    }
+  }
+
+  frequencyData(event: any) {
+    this.activeDeselector();
+    this.frequencyDataPopulate(event);
+    this.riskForm.frequency_details = {
+      frequency: event?.frequency,
+      started_at: event?.started_at,
+      frequency_time: event?.frequency_time,
+      remind_before_days: event?.remind_before_days,
+      can_assess_before_days: event?.can_assess_before_days,
+      failed_after_days: event?.failed_after_days,
+    };
+    this.frequencyPlaceholder = event?.placeholder;
+    this.pickerChanged.emit(false);
+  }
+
+  getFrequencyPlaceholder(res: any) {
+    try {
+      if (res?.frequency) {
+        const frequencyDetails = res?.frequency.split('~');
+        const frequencyTime =
+          res?.frequency_time === '00:00:00' ? '12:00 am' : res?.frequency_time;
+        switch (parseInt(frequencyDetails[0])) {
+          case 2:
+            this.getWeeklyPlaceholder(frequencyDetails, frequencyTime);
+            break;
+          case 3:
+            this.getMonthlyPlaceholder(frequencyDetails, frequencyTime);
+            break;
+          case 4:
+            this.getYearlyPlaceholder(frequencyDetails, frequencyTime);
+            break;
+          case 7:
+            this.getQuarterlyPlaceholder(frequencyDetails, frequencyTime);
+            break;
+          case 9:
+            this.getBiannualPlaceholder(frequencyDetails, frequencyTime);
+            break;
+          case 0:
+            {
+              const dateObject = new Date(
+                moment(
+                  frequencyDetails[1] +
+                    '-' +
+                    frequencyDetails[2] +
+                    '-' +
+                    frequencyDetails[3] +
+                    ' 00:00:00',
+                  'YYYY-MM-DD HH:mm:ss'
+                ).unix() * 1000
+              );
+              // tslint:disable-next-line: max-line-length
+              this.frequencyPlaceholder =
+                'One Time ' +
+                dateObject.getDate() +
+                ' ' +
+                this.shortMonth[dateObject.getMonth()] +
+                ' ' +
+                dateObject.getFullYear() +
+                ' by ' +
+                frequencyTime;
+            }
+            break;
+        }
+      }
+    } catch (e) {
+      // tslint:disable-next-line: no-console
+      console.log(e);
+    }
+  }
+
+  /**
+   * It takes a frequencyDetails array and a frequencyTime string and returns a frequencyPlaceholder
+   * string.
+   * @param {any} frequencyDetails - ["1", "1,2,3,4,5", "1", "1", "1", "1", "1", "1", "1", "1", "1",
+   * "1", "1", "1", "1", "1", "1", "
+   * @param {any} frequencyTime - "10:00 AM"
+   */
+  getWeeklyPlaceholder(frequencyDetails: any, frequencyTime: any) {
+    {
+      const selectedDay = frequencyDetails[1].split(',').map((ele: any) => {
+        return this.frequencyService.dayName[parseInt(ele) - 1];
+      });
+
+      if (parseInt(frequencyDetails[3]) === 1) {
+        this.frequencyPlaceholder =
+          'Every ' + selectedDay.join() + ' by ' + frequencyTime;
+      }
+      if (parseInt(frequencyDetails[3]) === 2) {
+        this.frequencyPlaceholder =
+          'Every alternate ' + selectedDay.join() + ' by ' + frequencyTime;
+      }
+      if (parseInt(frequencyDetails[3]) === 3) {
+        this.frequencyPlaceholder =
+          'Every 3rd ' + selectedDay.join() + ' by ' + frequencyTime;
+      }
+      if (parseInt(frequencyDetails[3]) > 3) {
+        this.frequencyPlaceholder =
+          'Every ' +
+          parseInt(frequencyDetails[3]) +
+          'th ' +
+          selectedDay.join() +
+          ' by ' +
+          frequencyTime;
+      }
+    }
+  }
+
+  /**
+   * It takes a string of comma separated numbers and returns a string of comma separated month names.
+   * @param {any} frequencyDetails - ["1", "1", "1,2,3,4,5,6,7,8,9,10,11,12"]
+   * @param {any} frequencyTime - "10:00 AM"
+   */
+  getMonthlyPlaceholder(frequencyDetails: any, frequencyTime: any) {
+    {
+      const selectedMonth = frequencyDetails[2].split(',').map((ele: any) => {
+        return this.shortMonth[parseInt(ele) - 1];
+      });
+      if (parseInt(frequencyDetails[1]) === 1) {
+        this.frequencyPlaceholder =
+          '1st of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 2) {
+        this.frequencyPlaceholder =
+          '2nd of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 3) {
+        this.frequencyPlaceholder =
+          '3rd of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (
+        parseInt(frequencyDetails[1]) === 21 ||
+        parseInt(frequencyDetails[1]) === 31
+      ) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'st of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 22) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'nd of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 23) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'rd of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) > 3) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'th of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      }
+    }
+  }
+
+  /**
+   * If the frequencyDetails[1] is less than 2, then the frequencyPlaceholder is set to the 1st, 2nd,
+   * 3rd, or nth of every month by frequencyTime.
+   *
+   * If the frequencyDetails[1] is greater than 1, then the frequencyPlaceholder is set to the 1st,
+   * 2nd, 3rd, or nth of every month, Interval: every yearSequence years by frequencyTime.
+   *
+   * I'm trying to write a test that will test the above function.
+   *
+   * Here's what I have so far:
+   * @param {any} frequencyDetails - [0] = "Yearly"
+   * @param {any} frequencyTime - "10:00 AM"
+   */
+  getYearlyPlaceholder(frequencyDetails: any, frequencyTime: any) {
+    {
+      const yearSequence =
+        parseInt(frequencyDetails[3]) > 0 ? parseInt(frequencyDetails[3]) : 1;
+      if (yearSequence < 2) {
+        if (parseInt(frequencyDetails[1]) === 1) {
+          this.frequencyPlaceholder =
+            '1st of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 2) {
+          this.frequencyPlaceholder =
+            '2nd of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 3) {
+          this.frequencyPlaceholder =
+            '3rd of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) > 3) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'th of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (
+          parseInt(frequencyDetails[1]) === 31 ||
+          parseInt(frequencyDetails[1]) === 21
+        ) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'st of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 22) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'nd of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 23) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'rd of every ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ' by ' +
+            frequencyTime;
+        }
+      }
+
+      if (yearSequence > 1) {
+        if (parseInt(frequencyDetails[1]) === 1) {
+          // tslint:disable-next-line: max-line-length
+          this.frequencyPlaceholder =
+            '1st of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 2) {
+          // tslint:disable-next-line: max-line-length
+          this.frequencyPlaceholder =
+            '2nd of' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 3) {
+          // tslint:disable-next-line: max-line-length
+          this.frequencyPlaceholder =
+            '3rd of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) > 3) {
+          // tslint:disable-next-line: max-line-length
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'th of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (
+          parseInt(frequencyDetails[1]) === 31 ||
+          parseInt(frequencyDetails[1]) === 21
+        ) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'st of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 22) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'nd of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+        if (parseInt(frequencyDetails[1]) === 23) {
+          this.frequencyPlaceholder =
+            parseInt(frequencyDetails[1]) +
+            'rd of ' +
+            this.shortMonth[parseInt(frequencyDetails[2]) - 1] +
+            ', Interval: every ' +
+            yearSequence +
+            ' years by ' +
+            frequencyTime;
+        }
+      }
+    }
+  }
+
+  /**
+   * If the frequencyDetails[1] is 1, 2, 3, 21, 22, 23, or greater than 3, then set the
+   * frequencyPlaceholder to a string that includes the frequencyDetails[1] and the frequencyTime.
+   * @param {any} frequencyDetails - ["3", "1", "1,2,3"]
+   * @param {any} frequencyTime - "10:00 AM"
+   */
+  getQuarterlyPlaceholder(frequencyDetails: any, frequencyTime: any) {
+    {
+      const quarterly = [
+        'January, April, July, October',
+        'February, May, August, November',
+        ' March, June, September, December',
+      ];
+      if (parseInt(frequencyDetails[1]) === 1) {
+        this.frequencyPlaceholder =
+          '1st of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 2) {
+        this.frequencyPlaceholder =
+          '2nd of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 3) {
+        this.frequencyPlaceholder =
+          '3rd of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (
+        parseInt(frequencyDetails[1]) === 21 ||
+        parseInt(frequencyDetails[1]) === 31
+      ) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'st of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 22) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'nd of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 23) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'rd of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) > 3) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'th of every ' +
+          quarterly[parseInt(frequencyDetails[2].split(',')[0]) - 1] +
+          ' by ' +
+          frequencyTime;
+      }
+    }
+  }
+
+  /**
+   * It takes a string of comma separated numbers and returns a string of comma separated month names.
+   * @param {any} frequencyDetails - ["1", "1", "1,2,3,4,5,6,7,8,9,10,11,12"]
+   * @param {any} frequencyTime - "10:00 AM"
+   */
+  getBiannualPlaceholder(frequencyDetails: any, frequencyTime: any) {
+    {
+      const selectedMonth = frequencyDetails[2].split(',').map((ele: any) => {
+        return this.shortMonth[parseInt(ele) - 1];
+      });
+      if (parseInt(frequencyDetails[1]) === 1) {
+        this.frequencyPlaceholder =
+          '1st of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 2) {
+        this.frequencyPlaceholder =
+          '2nd of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 3) {
+        this.frequencyPlaceholder =
+          '3rd of every ' + selectedMonth.join(', ') + ' by ' + frequencyTime;
+      } else if (
+        parseInt(frequencyDetails[1]) === 21 ||
+        parseInt(frequencyDetails[1]) === 31
+      ) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'st of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 22) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'nd of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) === 23) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'rd of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      } else if (parseInt(frequencyDetails[1]) > 3) {
+        this.frequencyPlaceholder =
+          parseInt(frequencyDetails[1]) +
+          'th of every ' +
+          selectedMonth.join(', ') +
+          ' by ' +
+          frequencyTime;
+      }
+    }
+  }
+
+  /**
+   * It takes an event object, and if it exists, it creates a new object with the same properties as
+   * the event object, and assigns it to the frequencyDetails property.
+   *
+   * If the event object is undefined, then the frequencyDetails property will be undefined.
+   *
+   * If the event object is null, then the frequencyDetails property will be null.
+   *
+   * If the event object is an empty object, then the frequencyDetails property will be an empty
+   * object.
+   *
+   * If the event object is an object with properties, then the frequencyDetails property will be an
+   * object with the same properties.
+   *
+   * If the event object is an object with properties, but some of those properties are undefined, then
+   * the frequencyDetails property will be an object with the same properties, but some of those
+   * properties will be undefined.
+   *
+   * If the event object is an object with properties, but some of those properties are null, then the
+   * @param {any} event - any = {
+   */
+  frequencyDataPopulate(event: any) {
+    let data = {
+      frequency: event?.frequency,
+      started_at: event?.started_at,
+      frequency_time: event?.frequency_time,
+      remind_before_days: event?.remind_before_days,
+      failed_after_days: event?.failed_after_days,
+      can_assess_before_days: event?.can_assess_before_days,
+    };
+    this.frequencyDetails = data;
+  }
+
+  /**
+   * The function `getOtherGRCTabCount` retrieves the count of different types of items (assets,
+   * processes, vendors, inventory) and updates the corresponding tabs with the count.
+   * @param {any} [event] - The "event" parameter is an optional parameter that can be passed to the
+   * "getOtherGRCTabCount" function. It is of type "any", which means it can accept any data type.
+   */
+  getOtherGRCTabCount(event?: any) {
+    event['rc_ids'] = this.getAllRCIds(this.riskForm.responsibilityCentersList);
+    this.grcTabLoader = true;
+    this.grcService.getGRCTabsCount(event).subscribe((data: any) => {
+      this.otherGRCCard.forEach((tab: any, index: number) => {
+        const OBJECT_LABEL: any = {
+          ASSET: 'Assets',
+          PROCESS: 'Processes',
+          VENDOR: 'Vendors',
+          INVENTORY: 'Inventory',
+        };
+        this.grcTabLoader = false;
+        const TAB_NAME = OBJECT_LABEL[tab?.title?.toUpperCase()];
+        if (TAB_NAME) {
+          tab.title = TAB_NAME;
+          tab.value = index;
+          tab.selectedCount = 0;
+          tab.key = TAB_NAME?.toLowerCase();
+        }
+        const key = `${tab.key}_type_count`;
+        if (data.hasOwnProperty(key)) {
+          tab.count = data[key];
+        }
+      });
+    });
+  }
+
+  getAllRCIds(rcIds: any) {
+    const allIds: number[] = rcIds.flatMap((rc: any) => [
+      ...rc.item_parent_ids.map(Number),
+      ...rc.item_child_ids.map(Number),
+      Number(rc.rc_id),
+    ]);
+
+    return this.responsibilityCentersList
+      .filter((rc: any) => allIds.includes(rc?.rc_id))
+      .map((ele: any) => ele._id)
+      .join(',');
+  }
+
+  getOtherGRCObjects(event?: any) {
+    if (this.otherGRCSubscription) {
+      this.otherGRCSubscription.unsubscribe();
+    }
+    if (!event) {
+      event = {
+        rc_ids: '',
+        type: this.selectedGRCTab,
+        state: 1,
+        page: 1,
+      };
+    }
+    if (event?.searchString && this.grcSearchString !== event?.searchString) {
+      this.grcSearchString = event?.searchString;
+      this.getOtherGRCTabCount({
+        rc_ids: '',
+        searchString: this.grcSearchString,
+      });
+    }
+    this.grcLoader = true;
+    event['rc_ids'] = this.getAllRCIds(this.riskForm.responsibilityCentersList);
+    event['grcType'] = this.selectedGRCTab;
+    this.otherGRCSubscription = this.grcService
+      .getGRCList(event)
+      .subscribe((data: any) => {
+        this.grcList = data;
+        this.grcLoader = false;
+        // if (this.MODE === 'EDIT') {
+        //   // this.listObject.OTHER_GRC_OBJECTS.selectedData = data.filter(
+        //   //   (item: any) => this.grcPayload.linked_GRC_ids.includes(item?._id)
+        //   // );
+        //   if (this.grcPayload.linked_GRC_ids?.length) {
+        //     this.grcForm.otherGrcObjects = true;
+        //     this.additionalOption.OTHER_GRC_OBJECTS = true;
+        //     this.populateOptionalFields();
+        //   }
+        // }
+      });
+  }
+
+  saveSelectedList(event: any) {
+    this.riskForm.selectedGRCObjects = event;
+    this.activateSelector('GRC', false);
+    this.setOtherGRCTypesFormate();
+  }
+  setOtherGRCTypesFormate() {
+    const grcTypes = GRC_TYPE_ARRAY;
+    this.resetGRCDataWithTypes();
+    if (this.riskForm?.selectedGRCObjects?.length > 0) {
+      this.riskForm?.selectedGRCObjects?.forEach((item: any) => {
+        this.grcDataWithTypes[grcTypes[item?.type]]?.push(item);
+      });
+    }
+  }
+
+  removeOtherGRCObjects(event: any) {
+    const grcTypes = GRC_TYPE_ARRAY;
+    this.riskForm.selectedGRCObjects = this.riskForm?.selectedGRCObjects.filter(
+      (grc: any) => grc?._id !== event?._id
+    );
+    this.filterOtherGRCData(event, grcTypes[event?.type]);
+    this.otherGRCCard[0].selectedCount
+      ? (this.otherGRCCard[event?.type].selectedCount -= 1)
+      : 0;
+  }
+
+  filterOtherGRCData(event: any, type: string) {
+    this.grcDataWithTypes[type] = this.grcDataWithTypes[type]?.filter(
+      (grc: any) => grc?._id !== event?._id
+    );
+  }
+
+  resetGRCDataWithTypes() {
+    this.grcDataWithTypes = {
+      assets: [],
+      processes: [],
+      vendors: [],
+      inventory: [],
+    };
+  }
+}