vcomply-workflow-engine 2.0.4 → 2.0.167

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

@@ -0,0 +1,871 @@
+import {
+  Component,
+  Input,
+  Output,
+  EventEmitter,
+  SimpleChanges,
+  OnChanges,
+  ChangeDetectionStrategy,
+  OnInit,
+} from '@angular/core';
+import { cloneDeep } from 'lodash';
+import * as XLSX from 'xlsx';
+import { CategoryList } from '../interfaces/categoryList';
+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 { FrequencyBulkService } from '../workflow-services/frequency.service';
+import moment from 'moment/moment';
+
+type AOA = any[][];
+@Component({
+  selector: 'app-add-multiple-risk',
+  templateUrl: './add-multiple-risk.component.html',
+  styleUrls: ['./add-multiple-risk.component.less', '../forms.less'],
+})
+export class AddMultipleRiskComponent implements OnInit, OnChanges {
+  @Output() pickerChanged = new EventEmitter();
+  @Output() populateOption = new EventEmitter();
+  @Output() closeWorkflow = new EventEmitter();
+  @Output() disconnectRefresh = new EventEmitter();
+  categoryList: CategoryList = {
+    strategic: {
+      name: 'STRATEGIC',
+      data: [],
+    },
+    operational: {
+      name: 'OPERATIONAL',
+      data: [],
+    },
+    compliance: {
+      name: 'COMPLIANCE',
+      data: [],
+    },
+    others: {
+      name: 'OTHERS',
+      data: [],
+    },
+  };
+
+  category: any = {
+    type: 'strategic',
+    selectedCategory: '',
+  };
+
+  riskBulkUpload: any = {
+    header: [],
+    weightFactors: [],
+    risks: [],
+  };
+
+  templateInfo: any = {
+    memberId: '',
+    categoryId: '',
+    ownerList: [],
+    rcList: [],
+    mitigationList: [],
+    likelihood: [],
+    impact: [],
+    velocity: [],
+    vulnerability: [],
+  };
+
+  isLoader = false;
+  showCategoryList = false;
+  templateDownloaded = false;
+  downloadInProgress = false;
+  loader = false;
+  settingsInfo!: any;
+  isFileEmpty = false;
+  isWrongFile = false;
+  isWrongFormat = false;
+  fileName: any;
+  data: any;
+  assessmentDeadLine: any;
+  showExcel = false;
+  fileValue: any;
+  memberId = 0;
+  organizationId = 0;
+  errorMessage = ' invalid file error';
+  downloadStatus: string = 'NOT_DOWNLOADING';
+  downloadPercent = 0;
+
+  smileyMessage = `You're All Set! We're uploading the risks. The risk owners will be notified once the risks have been uploaded.`;
+  actionButtons = [
+    { buttonText: 'Add More Risks', class: 'white-btn', id: 'addMore' },
+    { buttonText: 'View Risk', class: 'blue-btn', id: 'viewRisks' },
+  ];
+  showSmiley = false;
+  member_obj_id = '';
+  defaultOwner = '';
+  riskData!: any;
+  frequencyType = [
+    'weekly',
+    'monthly',
+    'quarterly',
+    'biannual',
+    'annual',
+    'one time',
+  ];
+
+  constructor(
+    private riskService: AddRiskService,
+    private authService: AuthService,
+    private snackBar: SnackBarService,
+    private frequencyService: FrequencyBulkService
+  ) {}
+
+  ngOnChanges(changes: SimpleChanges) {}
+  ngOnInit() {
+    this.pickerChanged.emit(false);
+    this.getCategoryList();
+    this.getSettingsInfo();
+
+    this.organizationId = this.authService.getOrganizationId();
+    this.memberId = this.authService.getMemberId();
+    this.member_obj_id = this.authService.getUserDetails()._id;
+  }
+  getCategoryList() {
+    this.isLoader = true;
+    this.riskService.getCategoryList().subscribe(
+      (res: any) => {
+        this.isLoader = false;
+        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;
+      },
+      (err) => {
+        console.error(err);
+        this.isLoader = false;
+      }
+    );
+  }
+  saveSelectedCategory(category: any) {
+    if (
+      this.category?.selectedCategory?.category_id !=
+      category?.selectedCategory?.category_id
+    ) {
+      this.downloadStatus = 'NOT_DOWNLOADING';
+    }
+    this.showCategoryList = false;
+    this.category = category;
+    const reference = document.querySelector('#scrollReference');
+    if (reference) {
+      reference.scrollIntoView({ behavior: 'smooth', block: 'center' });
+    }
+    this.reset();
+  }
+  removeCategory() {
+    this.category = {
+      type: 'strategic',
+      selectedCategory: '',
+    };
+    this.reset();
+  }
+  getSettingsInfo() {
+    this.riskService.getRiskSettingDetails().subscribe(
+      (res) => {
+        this.settingsInfo = res;
+      },
+      (err) => {
+        console.error(err);
+      }
+    );
+  }
+  triggerBrowseFile() {
+    const getFile = document.getElementById('fileInput');
+    if (getFile) {
+      getFile.click();
+    }
+  }
+
+  uploadedFile(event: any) {
+    try {
+      this.riskBulkUpload = {
+        header: [],
+        weightFactors: [],
+        risks: [],
+      };
+      this.templateInfo = {
+        memberId: '',
+        categoryId: '',
+        ownerList: [],
+        rcList: [],
+        mitigationList: [],
+        likelihood: [],
+        impact: [],
+        velocity: [],
+        vulnerability: [],
+      };
+      const reference = document.querySelector('#scrollReference');
+      if (reference) {
+        reference.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      }
+      this.isFileEmpty = false;
+      this.isWrongFile = false;
+      this.isWrongFormat = false;
+      this.fileName = event.target.files[0].name;
+
+      const target: DataTransfer = event.target as DataTransfer;
+      // tslint:disable-next-line: curly
+      if (target.files.length !== 1)
+        throw new Error('Cannot use multiple files');
+      const reader: FileReader = new FileReader();
+      reader.onload = (e: any) => {
+        const bstr: string = e.target.result;
+        const wb: XLSX.WorkBook = XLSX.read(bstr, { type: 'binary' });
+        const wsname: string = wb.SheetNames[0];
+        const wsname1: string = wb.SheetNames[1];
+
+        const ws: XLSX.WorkSheet = wb.Sheets[wsname];
+        const tempData: XLSX.WorkSheet = wb.Sheets[wsname1];
+
+        this.data = XLSX.utils.sheet_to_json(ws, {
+          header: 1,
+        }) as AOA;
+
+        const tData = XLSX.utils.sheet_to_json(tempData, { header: 1 }) as AOA;
+        const tempList = tData.filter(
+          (dataElement: any) => dataElement.length > 0
+        );
+        this.templateInfo.memberId = tempList[0][56];
+        this.templateInfo.categoryId = tempList[0][55];
+        this.riskBulkUpload.header = cloneDeep(
+          this.data[4].filter((dataElement: any) => dataElement.length > 0)
+        );
+        this.riskBulkUpload.weightFactors = cloneDeep(
+          this.data[5].filter((weightFactor: any) => weightFactor.length > 0)
+        );
+        tempList.forEach((element) => {
+          if (element[8]) {
+            const member = {
+              name: element[8],
+              member_id: element[9],
+            };
+            this.templateInfo.ownerList.push(member);
+          }
+          if (element[2]) {
+            const mitigation = {
+              mitigationName: element[2],
+              mitigation_id: element[3],
+            };
+            this.templateInfo.mitigationList.push(mitigation);
+          }
+          if (element[6]) {
+            const rc = {
+              rcName: element[6],
+              rc_id: element[7],
+              owner_ids: element[11],
+            };
+            this.templateInfo.rcList.push(rc);
+          }
+
+          if (element[12]) {
+            this.templateInfo?.likelihood.push(element[12]);
+          }
+          if (element[13]) {
+            this.templateInfo?.impact.push(element[13]);
+          }
+          if (
+            this.riskBulkUpload?.weightFactors?.includes('Velocity') &&
+            element[14]
+          ) {
+            this.templateInfo.velocity.push(element[14]);
+          }
+          if (
+            this.riskBulkUpload?.weightFactors?.includes('Vulnerability') &&
+            element[15]
+          ) {
+            this.templateInfo.vulnerability.push(element[15]);
+          }
+        });
+
+        if (this.fileName.substr(-5) !== '.xlsx') {
+          this.errorMessage =
+            'The incorrect file has been uploaded. Please upload the template file for Risk Category:' +
+            this.category.selectedCategory.category_name +
+            ' RETRY';
+
+          this.isWrongFile = true;
+          return;
+        }
+
+        if (
+          this.riskBulkUpload.header[0] !==
+          'What risk would you like to manage?*'
+        ) {
+          this.errorMessage =
+            'The incorrect file has been uploaded. Please upload the template file for Risk Category:' +
+            this.category.selectedCategory.category_name +
+            ' RETRY';
+
+          this.isWrongFile = false;
+          this.isWrongFormat = true;
+
+          return;
+        }
+        this.data = this.data?.slice(7);
+        const defaultOwner = this.templateInfo?.ownerList?.findIndex(
+          (ele: any) => ele?.member_id == this.memberId
+        );
+        if (defaultOwner != -1) {
+          this.defaultOwner = this.templateInfo.ownerList[defaultOwner].name;
+        } else {
+          this.errorMessage =
+            'The incorrect file has been uploaded. Please upload the template file for Risk Category:' +
+            this.category.selectedCategory.category_name +
+            ' RETRY';
+          this.isWrongFile = true;
+          return;
+        }
+
+        if (
+          this.member_obj_id != this.templateInfo.memberId ||
+          this.category.selectedCategory._id != this.templateInfo.categoryId
+        ) {
+          this.errorMessage =
+            'The incorrect file has been uploaded. Please upload the template file for Risk Category:' +
+            this.category.selectedCategory.category_name +
+            ' RETRY';
+
+          this.isWrongFile = true;
+          return;
+        }
+
+        const isEmpty = this.checkEmptyFile();
+        if (isEmpty) {
+          this.errorMessage =
+            'You have uploaded a blank template. Please add details for all mandatory fields. RETRY';
+          this.isFileEmpty = true;
+          this.isWrongFile = false;
+          this.isWrongFormat = false;
+          return;
+        } else {
+          if (this.riskBulkUpload.header[6] === 'Risk Assessment Deadline*') {
+            this.assessmentDeadLine = true;
+          } else {
+            this.assessmentDeadLine = false;
+          }
+          this.isFileEmpty = false;
+          this.isWrongFile = false;
+          this.isWrongFormat = false;
+          this.fileValue = '';
+        }
+        const riskData = this.data.filter(
+          (dataElement: any) => dataElement.length > 0
+        );
+
+        riskData.forEach((risk: any, index: any) => {
+          // const obj: any = {
+          //   riskName: risk[0] ?? '',
+          //   description: risk[1] ?? '',
+          //   rcName: risk[2] ?? '',
+          //   owner: risk[3] ?? '',
+          //   mitigationPriority: risk[4] ?? '',
+          //   overseer: risk[5] ?? '',
+          //   isValid: this.checkValidity(risk),
+          // }
+
+          // if (this.assessmentDeadLine) {
+          //   obj.assessmentDeadLine = risk[6] ?? '';
+          //   obj.likelihood = risk[7] ?? '';
+          //   obj.impact = risk[8] ?? '';
+          //   if (this.riskBulkUpload.weightFactors.length == 3) {
+          //     obj.velocity = risk[9] ?? '';
+          //   }
+          //   if (this.riskBulkUpload.weightFactors.length == 4) {
+          //     obj.velocity = risk[9] ?? '';
+          //     obj.vulnerability = risk[10] ?? '';
+          //   }
+          //   const customTags: any = [];
+
+          //   this.category.selectedCategory.custom_tag.forEach((tag: any, index: any) => {
+          //     if (tag) {
+          //       const cTag = {
+          //         custom_tag_value: risk[7 + this.riskBulkUpload.weightFactors.length + index] ?? '',
+          //         custom_tag_name: tag.tagName
+          //       };
+          //       customTags.push(cTag);
+          //     }
+          //   });
+          //   obj.customTag = customTags;
+          // } else {
+          //   obj.likelihood = risk[6] ?? '';
+          //   obj.impact = risk[7] ?? '';
+
+          //   if (this.riskBulkUpload.weightFactors.length == 3) {
+          //     obj.velocity = risk[8] ?? '';
+          //   }
+          //   if (this.riskBulkUpload.weightFactors.length == 4) {
+          //     obj.velocity = risk[8] ?? '';
+          //     obj.vulnerability = risk[9] ?? '';
+          //   }
+          //   const customTags: any = [];
+          //   this.category.selectedCategory.custom_tag.forEach((tag: any, index: any) => {
+          //     if (tag) {
+          //       const cTag = {
+          //         custom_tag_value: risk[6 + this.riskBulkUpload.weightFactors.length + index] ?? '',
+          //         custom_tag_name: tag.tagName
+          //       };
+          //       customTags.push(cTag);
+          //     }
+          //   });
+          //   obj.customTag = customTags;
+          // }
+          let obj = this.setRiskDetails(risk);
+          if (
+            obj?.likelihood &&
+            !this.templateInfo?.likelihood.includes(obj?.likelihood)
+          ) {
+            obj.isValid = false;
+          }
+          if (obj?.impact && !this.templateInfo?.impact.includes(obj?.impact)) {
+            obj.isValid = false;
+          }
+          if (
+            obj?.velocity &&
+            !this.templateInfo?.velocity.includes(obj?.velocity)
+          ) {
+            obj.isValid = false;
+          }
+          if (
+            obj?.vulnerability &&
+            !this.templateInfo?.vulnerability.includes(obj?.vulnerability)
+          ) {
+            obj.isValid = false;
+          }
+
+          this.riskBulkUpload.risks.push(obj);
+        });
+        this.isFileEmpty = false;
+        this.isWrongFile = false;
+        this.isWrongFormat = false;
+        this.showExcel = true;
+      };
+      reader.readAsBinaryString(target?.files[0]);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  checkEmptyFile() {
+    let isEmpty = false;
+    this.data = this.data.filter((dataElement: any) => dataElement.length > 0);
+    if (this.data.length < 1) {
+      isEmpty = true;
+    }
+    return isEmpty;
+  }
+
+  checkValidity(risk: any) {
+    const re = /&nbsp;|<br>/g;
+    let trimmedName = risk[0] ? risk[0].toString().replace(re, '').trim() : '';
+    trimmedName = trimmedName.replace(/  +/g, ' ');
+    // || (this.assessmentDeadLine && (!risk[6]))
+    if (
+      !trimmedName ||
+      (risk[3] && risk[3] == risk[6]) ||
+      (!risk[3] && this.defaultOwner == risk[6]) ||
+      !risk[2] ||
+      !this.frequencyType?.includes(risk[4]?.toLowerCase())
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  downloadTemplate() {
+    this.downloadStatus = 'DOWNLOADING';
+    this.downloadPercent = 0;
+    const today = new Date().toISOString().split('T');
+    const downloadDate = today[0];
+    const fileName =
+      'VComply - Risk Module - Add Multiple Risks - ' +
+      this.category?.selectedCategory?.category_name +
+      ' - ' +
+      downloadDate +
+      '.xlsx';
+
+    this.riskService
+      .downloadTemplate(this.category.selectedCategory._id)
+      .subscribe(
+        (data: any) => {
+          if (data.loaded) {
+            this.downloadPercent = 100 * (data.loaded / data.total);
+          }
+          if (data.body) {
+            setTimeout(() => {
+              this.downloadStatus = this.riskService.downLoadFile(
+                data.body,
+                'application/xlsx',
+                fileName
+              );
+            }, 1500);
+          }
+        },
+        (error) => {
+          console.error(error);
+          this.downloadStatus = 'DOWNLOADED';
+        }
+      );
+  }
+
+  submitRiskBulkUpload(completeAssessment: any) {
+    this.loader = true;
+    const payload: any = [];
+    this.riskBulkUpload.risks.forEach((risk: any) => {
+      let frequencyValue = '';
+      if (risk?.frequency.toLowerCase() === 'one time') {
+        const date = new Date();
+        date.setDate(date.getDate() + 1);
+        frequencyValue =
+          '0~' +
+          '' +
+          date.getFullYear() +
+          '~' +
+          (date.getMonth() + 1) +
+          '~' +
+          date.getDate();
+      } else {
+        frequencyValue = this.frequencyService.shortHand_freqCal(
+          risk?.frequency
+        );
+      }
+
+      if (risk.isValid) {
+        const obj = {
+          title: risk?.riskName,
+          description: risk?.description,
+          category_custom_tag: risk?.customTag,
+          assessment_deadline_enable:
+            this.settingsInfo?.assessment_deadline_enable,
+          owner: risk?.owner
+            ? this.returnIds(risk?.owner, 'owner')
+            : this.returnIds(this.defaultOwner, 'owner'),
+          category: this.category?.selectedCategory?.category_id
+            ? [this.category?.selectedCategory?.category_id]
+            : [],
+          manage_oversight: this.returnIds(risk?.overseer, 'overseer'),
+          rc_id: this.returnIds(risk?.rcName, 'rc_id'),
+          head_ids: this.returnIds(risk?.rcName, 'rc_owner_ids'), //2 to be aray
+          rating_arr: [
+            risk?.likelihood ? risk?.likelihood.split(' - ')[1] : 0,
+            risk?.impact ? risk?.impact.split(' - ')[1] : 0,
+            risk?.velocity ? risk?.velocity.split(' - ')[1] : 0,
+            risk?.vulnerability ? risk?.vulnerability.split(' - ')[1] : 0,
+          ],
+          member_id: this.memberId,
+          organisation_id: this.organizationId,
+          risk_progress_flag: 1,
+          IfAssessmentDone: 0,
+          workshop_id: '',
+          complete_assessment: completeAssessment ? 1 : 0,
+          mitigation: this.returnIds(risk?.mitigationPriority, 'mitigation'), //3 wrong
+          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, //check1 not appearing
+          assessment_deadline_set_by:
+            this.settingsInfo?.assessment_deadline_set_by ?? this.memberId, //check1 not appearing
+          assessment_deadline_days: this.settingsInfo
+            ?.assessment_deadline_enable
+            ? this.settingsInfo?.assessment_deadline_days
+            : risk?.assessmentDeadLine,
+          frequency_details: {
+            frequency: frequencyValue,
+            started_at:
+              this.changeTimeZone(new Date()) ?? moment().format('YYYY-MM-DD'),
+            frequency_time: '11:00 pm',
+            remind_before_days: risk?.emailReminder
+              ? risk?.emailReminder
+              : this.setDefaultEmailReminderValue(risk?.frequency),
+          },
+          risk_label: this.setRiskLabel(risk?.riskLabel),
+          mitigation_plan_recommendation: risk?.mitigationPlans ?? '',
+          sameRiskRatingsForAllRC: risk?.applySameRiskRating ?? 'No',
+        };
+        payload.push(obj);
+      }
+    });
+    console.log('payloadpayloadpayloadpayloadpayloadpayload  ====>', payload);
+
+    this.riskService.addBulkRisk(payload).subscribe(
+      (res: any) => {
+        this.loader = false;
+        this.showExcel = false;
+        this.showSmiley = true;
+        this.riskData = res;
+      },
+      (err) => {
+        console.log(err);
+        this.loader = false;
+        this.showExcel = false;
+        this.snackBar.show(
+          'OOPS! Something went wrong and the page could not be loaded. Could you please try one more time?',
+          'alert'
+        );
+      }
+    );
+  }
+
+  returnIds(item: any, key: string) {
+    switch (key) {
+      case 'rc_id':
+        const rcId: any = [];
+        this.templateInfo.rcList.forEach((rc_element: any) => {
+          if (rc_element.rcName == item) {
+            rcId.push(rc_element.rc_id);
+          }
+        });
+        return rcId;
+        break;
+      case 'rc_owner_ids':
+        let owner_ids: any = [];
+        this.templateInfo.rcList.forEach((headerIds: any) => {
+          if (headerIds.rcName == item && headerIds.owner_ids) {
+            owner_ids = headerIds.owner_ids.includes(',')
+              ? headerIds.owner_ids.split(',').map(Number)
+              : [Number(headerIds.owner_ids)];
+          }
+        });
+        return owner_ids;
+        break;
+      case 'owner':
+        const ownerId: any = [];
+        this.templateInfo.ownerList.forEach((element: any) => {
+          if (element.name == item) {
+            ownerId.push(element.member_id);
+          }
+        });
+        return ownerId;
+        break;
+      case 'overseer':
+        const overseerId: any = [];
+        this.templateInfo.ownerList.forEach((os_element: any) => {
+          if (os_element.name == item) {
+            overseerId.push(os_element.member_id);
+          }
+        });
+        return overseerId;
+        break;
+
+      case 'mitigation':
+        let mitigationId: any = 0;
+        this.templateInfo.mitigationList.forEach((mitigation: any) => {
+          if (mitigation.mitigationName == item) {
+            mitigationId = mitigation.mitigation_id;
+          }
+        });
+        return mitigationId;
+        break;
+    }
+  }
+
+  reset() {
+    this.riskBulkUpload = {
+      header: [],
+      weightFactors: [],
+      risks: [],
+    };
+
+    this.templateInfo = {
+      memberId: '',
+      categoryId: '',
+      ownerList: [],
+      rcList: [],
+      mitigationList: [],
+    };
+
+    this.isFileEmpty = false;
+    this.isWrongFile = false;
+    this.isWrongFormat = false;
+    this.fileName = undefined;
+    this.data = undefined;
+    this.assessmentDeadLine = undefined;
+    this.showExcel = false;
+    this.showSmiley = false;
+  }
+  action(event: string) {
+    switch (event) {
+      case 'addMore':
+        this.category = {
+          type: 'strategic',
+          selectedCategory: '',
+        };
+        this.downloadStatus = 'NOT_DOWNLOADING';
+        this.reset();
+        break;
+      case 'viewRisks':
+        this.viewRisks();
+        break;
+    }
+  }
+
+  closeSmiley(event: any) {
+    this.showSmiley = 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-register';
+    } else {
+      url += '/risk/risk-register';
+    }
+    window.location.href = url;
+  }
+
+  /**
+   * It takes an array of strings and returns an object with the array values as properties.
+   * </code>
+   * @param {any} risk - any = [
+   * @returns [
+   *   {
+   *     "riskName": "",
+   *     "description": "",
+   *     "rcName": "",
+   *     "owner": "",
+   *     "frequency": "",
+   *     "emailReminder": "",
+   *     "overseer": "",
+   *     "isValid": false,
+   *     "mitigationPriority": "",
+   */
+  setRiskDetails(risk: any) {
+    let obj: any;
+    obj = {
+      riskName: risk[0] ?? '',
+      description: risk[1] ?? '',
+      rcName: risk[2] ?? '',
+      owner: risk[3] ?? '',
+      frequency: risk[4] ?? '',
+      emailReminder: risk[5],
+      overseer: risk[6] ?? '',
+      isValid: this.checkValidity(risk),
+    };
+    let index = 7;
+    if (
+      this.riskBulkUpload?.header?.includes('Recommended Mitigation Priority')
+    ) {
+      obj['mitigationPriority'] = risk[index] ?? '';
+      index++;
+    }
+    obj['mitigationPlans'] = risk[index] ?? '';
+    index++;
+    obj['riskLabel'] = risk[index] ?? '';
+    index++;
+    obj['likelihood'] = risk[index] ?? '';
+    index++;
+    obj['impact'] = risk[index] ?? '';
+    index++;
+    if (this.riskBulkUpload?.weightFactors?.includes('Velocity')) {
+      obj['velocity'] = risk[index] ?? '';
+      index++;
+    }
+    if (this.riskBulkUpload?.weightFactors?.includes('Vulnerability')) {
+      obj['vulnerability'] = risk[index] ?? '';
+      index++;
+    }
+    if (
+      this.riskBulkUpload?.header?.includes(
+        'Do you want to apply the same risk ratings for all Responsibility Centers?'
+      )
+    ) {
+      obj['applySameRiskRating'] = risk[index] ?? '';
+      index++;
+    }
+    const customTags: any = [];
+    this.category?.selectedCategory?.custom_tag?.forEach((tag: any, i: any) => {
+      if (tag) {
+        const cTag = {
+          custom_tag_value: risk[index + i] ?? '',
+          custom_tag_name: tag.tagName,
+        };
+        customTags.push(cTag);
+      }
+    });
+    obj['customTag'] = customTags;
+    obj['isValidFrequency'] = this.frequencyType?.includes(
+      obj?.frequency?.toLowerCase()
+    );
+    return obj;
+  }
+
+  /**
+   * If the frequencyType is weekly, return 2, if it's monthly, return 7, if it's quarterly, return 7,
+   * if it's biannual, return 30, if it's annual, return 30, if it's one time, return 15, otherwise
+   * return 0.
+   * @param {string} [frequencyType] - string - the frequency type of the reminder
+   * @returns The return value is the number of days before the event that the reminder should be sent.
+   */
+  setDefaultEmailReminderValue(frequencyType?: string): any {
+    switch (frequencyType?.toLowerCase()) {
+      case 'weekly':
+        return 2;
+      case 'monthly':
+        return 7;
+      case 'quarterly':
+        return 7;
+      case 'biannual':
+        return 30;
+      case 'annual':
+        return 30;
+      case 'one time':
+        return 15;
+      default:
+        return 0;
+    }
+  }
+
+  /**
+   * If the label is 'new risk', return 1, if the label is 'emerging/rapidly changing risks', return 2,
+   * otherwise return 1
+   * @param {string} [label] - the label of the risk
+   * @returns The return value is the value of the last expression in the function.
+   */
+  setRiskLabel(label?: string) {
+    switch (label?.toLowerCase()) {
+      case 'newly identified risks':
+        return 1;
+      case 'rapidly changing risks':
+        return 2;
+      default:
+        return 1;
+    }
+  }
+
+  /**
+   * "If the date is a number, convert it to a date object, then create a new date object with the
+   * timezone set to the user's timezone, then return the date in the format YYYY-MM-DD."
+   * </code>
+   * @param {any} date - any - the date you want to change the timezone of
+   * @returns The date is being returned in the timezone of the user.
+   */
+  changeTimeZone(date: any) {
+    if (typeof date === 'number') {
+      date = new Date(date);
+    }
+    const invDate = new Date(
+      date.toLocaleString('en-US', {
+        timeZone: this.authService.userDetails?.timezone,
+      })
+    );
+    return moment(invDate).format('YYYY-MM-DD');
+  }
+}