vcomply-workflow-engine 2.0.4 → 2.0.167

package/projects/vx-workflow-engine/src/lib/workflow/grc-object/grc-object-container/grc-object-container.component.ts

@@ -0,0 +1,980 @@
+import { Component, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FIELD_TEXT } from '../../shared/constants/field-text.constant';
+import { LINKS } from '../../shared/constants/cdn-link.constant';
+import { VALIDATION_MESSAGE } from '../../shared/constants/validation-message.constant';
+import {
+  AddGrc,
+  Attributes,
+  Button,
+  GRCType,
+  InputType,
+  ListObject,
+  OpenedPopup,
+} from '../../shared/interfaces/add-grc';
+import { GrcService } from '../../shared/services/grc.service';
+import { ResponsibilityService } from '../../../workflow-services/responsibility.service';
+import { AuthService } from '../../../workflow-services/auth.service';
+import {
+  GRC_TYPE_ARRAY,
+  OTHER_GRC_CARD,
+  OTHER_GRC_TAB_INDEX,
+  SMILEY_BUTTONS,
+  UNCATEGORIZED_LINK_CATEGORY,
+} from '../../shared/constants/grcObject.constant';
+import { SUCCESS_MESSAGE } from '../../shared/constants/message.contstant';
+import { Subscription } from 'rxjs';
+import { UiKitService } from '../../../workflow-services/ui-kit.service';
+
+@Component({
+  selector: 'lib-grc-object-container',
+  templateUrl: './grc-object-container.component.html',
+  styleUrls: ['./grc-object-container.component.less', '../../../forms.less'],
+  outputs: [
+    'populateOption',
+    'pickerChanged',
+    'closeWorkflow',
+    'disconnectRefresh',
+    'resetForm',
+    'hideElementsFromMoreOptions',
+  ],
+  inputs: ['grcType', 'MODE', 'ID'],
+})
+export class GrcObjectContainerComponent implements OnInit, OnDestroy {
+  MODE: 'CREATE' | 'EDIT' = 'CREATE';
+  ID: string = '';
+  ALL_TEXT = FIELD_TEXT;
+  CDN_LINK = LINKS;
+  VALIDATION_MESSAGE = VALIDATION_MESSAGE;
+  GRC_TYPE_ARRAY = GRC_TYPE_ARRAY;
+  EDITOR_CONFIG = GrcService.EDITOR_CONFIG;
+  otherGRCCard = JSON.parse(JSON.stringify(OTHER_GRC_CARD));
+  OBJECT_TYPE!: GRCType[];
+  LIST_POPUP: Array<string> = ['RC'];
+  smileyMessage: string = SUCCESS_MESSAGE.ADD_GRC_OBJECT;
+  INPUT_TYPE: InputType = {
+    name: 'NAME',
+    owner: 'OWNER',
+    RC: 'RC',
+    riskCategory: 'RISK_CATEGORY',
+    otherGrcObjects: 'OTHER_GRC_OBJECTS',
+    programResponsibility: 'PROGRAM_RESPONSIBILITY',
+  };
+  ORIGINAL_GRC_ATTRIBUTES: any; // Don't change the value once it is assigned
+  dialogFields: Array<string> = [
+    'RC',
+    'OWNER',
+    'OTHER_GRC_OBJECTS',
+    'RISK_CATEGORY',
+    'ATTRIBUTES',
+    'PROGRAM_RESPONSIBILITY',
+  ];
+  scrollToBottom = false;
+  grcType: 0 | 1 | 2 | 3 = 0;
+  disabledIds: Array<number> = [];
+  openedPopup: OpenedPopup['type'] = '';
+  isLoading: boolean = true;
+  additionalOption: any = {
+    ATTRIBUTES: false,
+    LINK_PROGRAM: false,
+    LINK_RISK_CATEGORIES_RISKS: false,
+    OTHER_GRC_OBJECTS: false,
+  };
+  grcForm: any = {
+    grcObjectType: false,
+    linkProgram: false,
+    linkRisk: false,
+    otherGrcObjects: false,
+  };
+  grcPayload!: AddGrc;
+  listObject!: ListObject;
+  selectedAttributes!: GRCType;
+  showSmiley: boolean = false;
+  actionButtons: Button[] = SMILEY_BUTTONS;
+  grcDataWithTypes: any = {
+    assets: [],
+    processes: [],
+    vendors: [],
+    inventory: [],
+  };
+  GRCSelectedTab: number = 0;
+  otherGRCTabIndex = OTHER_GRC_TAB_INDEX;
+  isFormSubmitted: boolean = false;
+  grcNameValidationError: string = '';
+  isDuplicateName: boolean = false;
+  detailsLoader: boolean = false;
+  selectedCategories: any[] = [];
+  selectedRisks: any[] = [];
+  addedGRC: any;
+  otherGRCSearch: string = '';
+  grcTabLoader: boolean = false;
+  selectedProgram: any[] = [];
+  selectedResponsibility: any[] = [];
+
+  populateOption: EventEmitter<any> = new EventEmitter();
+  pickerChanged: EventEmitter<any> = new EventEmitter();
+  closeWorkflow: EventEmitter<any> = new EventEmitter();
+  disconnectRefresh: EventEmitter<any> = new EventEmitter();
+  resetForm: EventEmitter<any> = new EventEmitter();
+  hideElementsFromMoreOptions: EventEmitter<any> = new EventEmitter();
+
+  otherGRCSubscription!: Subscription;
+  hideMoreOption: any = [];
+
+  constructor(
+    private grcService: GrcService,
+    private apiService: ResponsibilityService,
+    private authService: AuthService,
+    private uiKitService: UiKitService
+  ) {}
+  ngOnDestroy(): void {
+    this.resetGRCForm();
+  }
+
+  ngOnInit(): void {
+    this.grcPayload = JSON.parse(JSON.stringify(this.grcService.GRC_PAYLOAD));
+    this.grcPayload.type = this.grcType;
+    this.listObject = this.grcService.LIST_OBJECT;
+    this._initiateAPI();
+    this.getSubscriptionDetails();
+  }
+
+  getSubscriptionDetails() {
+    this.authService.getSubscriptionDetails().subscribe((res: any) => {
+      if (!res[0]?.risk_flag) {
+        this.hideMoreOption.push('LINK_RISK_CATEGORIES_RISKS');
+        this.hideElementsFromMoreOptions.emit(this.hideMoreOption);
+      }
+    });
+  }
+
+  populateOptionalFields() {
+    const activatedOptions = [];
+    for (const key of Object.keys(this.additionalOption)) {
+      if (this.additionalOption[key] === true) {
+        activatedOptions.push(key);
+      }
+    }
+
+    this.populateOption.emit(activatedOptions);
+  }
+
+  //TODO: implement this
+  addMoreInfo(event: any) {
+    switch (event?.code) {
+      case 'ATTRIBUTES':
+        this.grcForm.grcObjectType = event?.checked;
+        break;
+      case 'LINK_PROGRAM':
+        this.grcForm.linkProgram = event?.checked;
+        break;
+      case 'LINK_RISK_CATEGORIES_RISKS':
+        this.grcForm.linkRisk = event?.checked;
+        break;
+      case 'OTHER_GRC_OBJECTS':
+        this.grcForm.otherGrcObjects = event?.checked;
+        break;
+    }
+    this.scrollToBottom = true;
+  }
+
+  //TODO: implement this
+  onTextChange(event: any) {
+    this.grcPayload.name = event.trim();
+    this.openedPopup = '';
+    this.grcNameValidationError = '';
+    this.isDuplicateName = false;
+  }
+
+  //TODO: implement this
+  onPopupOpen(type: OpenedPopup['type']) {
+    switch (type) {
+      case 'OWNER':
+      case 'RC':
+        this.openedPopup = type;
+        this.pickerChanged.emit(true);
+        break;
+      case 'OTHER_GRC_OBJECTS':
+        this.openedPopup = type;
+        this.getOtherGRCObjects({ rc_ids: '' });
+        this.getOtherGRCTabCount({ rc_ids: '' });
+        this.pickerChanged.emit(true);
+        break;
+      case 'RISK_CATEGORY':
+        this.openedPopup = type;
+        this.authService.previewPanel.next(true);
+        this.pickerChanged.emit(true);
+        break;
+      case 'PROGRAM_RESPONSIBILITY':
+        this.openedPopup = type;
+        this.authService.previewPanel.next(true);
+        this.pickerChanged.emit(true);
+        break;
+      default:
+    }
+  }
+
+  onSaveSelectedList(event: any) {
+    this.listObject = event;
+    if (this.openedPopup === 'OTHER_GRC_OBJECTS') {
+      this.setOtherGRCTypesFormate();
+    }
+    this.setListPayload(this.openedPopup);
+    this.openedPopup = '';
+    this.pickerChanged.emit(false);
+    this.authService.previewPanel.next(false);
+  }
+
+  getAttributeSelection(event: any) {
+    if (event) {
+      this.openedPopup = '';
+      this.pickerChanged.emit(true);
+    } else {
+      this.openedPopup = '';
+      this.pickerChanged.emit(false);
+      this.authService.previewPanel.next(false);
+    }
+  }
+
+  setListPayload(type: string) {
+    if (type === 'OWNER') {
+      this.grcPayload.owners = this.listObject.OWNER.selectedData.map(
+        (item: any) => item.member_id
+      );
+    }
+
+    if (type === 'RC') {
+      let previousRCIds = JSON.parse(JSON.stringify(this.grcPayload.rc_ids));
+      this.grcPayload.rc_ids = this.listObject.RC.selectedData.map(
+        (item: any) => item?._id
+      );
+      if (
+        !previousRCIds.every((id: any) => this.grcPayload.rc_ids.includes(id))
+      ) {
+        this.resetDataOnRCChange();
+      }
+    }
+    if (type === 'OTHER_GRC_OBJECTS') {
+      this.grcPayload.linked_GRC_ids =
+        this.listObject.OTHER_GRC_OBJECTS.selectedData.map(
+          (item: any) => item._id
+        );
+    }
+    if (type === 'RISK_CATEGORY') {
+      this.grcPayload.risk_category_ids = this.getRiskCategoryPayload(
+        this.listObject?.RISK_CATEGORY?.selectedData
+      );
+    }
+    if (type === 'PROGRAM_RESPONSIBILITY') {
+      this.grcPayload.program_category_ids =
+        this.getProgramResponsibilityPayload(
+          this.listObject?.PROGRAM_RESPONSIBILITY?.selectedData
+        );
+    }
+  }
+
+  onClickOutside() {
+    //this.openedPopup = '';
+  }
+
+  onEdit(event: any, subType: string) {
+    this.openedPopup = event;
+    if (event === 'OTHER_GRC_OBJECTS') {
+      this.GRCSelectedTab = this.otherGRCTabIndex[subType] ?? 0;
+      this.getOtherGRCObjects({ type: this.GRCSelectedTab, rc_ids: '' });
+      this.getOtherGRCTabCount({ rc_ids: '' });
+    }
+    if (this.LIST_POPUP.includes(event)) {
+      this.pickerChanged.emit(true);
+      // this.authService.previewPanel.next(true);
+    }
+    if (event === 'RISK_CATEGORY' || event === 'PROGRAM_RESPONSIBILITY') {
+      this.authService.previewPanel.next(true);
+    }
+  }
+
+  onRemoveData(
+    event: any,
+    type:
+      | 'RC'
+      | 'OWNER'
+      | 'OTHER_GRC_OBJECTS'
+      | 'RISK_CATEGORY'
+      | 'PROGRAM_RESPONSIBILITY'
+  ) {
+    switch (type) {
+      case 'RC':
+        this.listObject[type].selectedData.splice(event.index, 1);
+        this.resetDataOnRCChange();
+        break;
+      case 'OWNER':
+        this.listObject[type].selectedData.splice(event.index, 1);
+        break;
+      case 'OTHER_GRC_OBJECTS':
+        this.removeOtherGRCObjects(event?.data);
+        break;
+      case 'RISK_CATEGORY':
+        this.deleteSelectedRisk(event.data?.CategoryIds[0], event?.data);
+        break;
+      case 'PROGRAM_RESPONSIBILITY':
+        this.deleteSelectedResponsibility(event?.data);
+        break;
+    }
+    this.setListPayload(type);
+  }
+
+  changeAttributesType(event: any) {
+    this.grcType = event;
+    this.grcPayload.type = event;
+    this.setDefaultGRCObjectType();
+  }
+
+  private _initiateAPI() {
+    if (this.MODE === 'EDIT') {
+      this.getGRCObjectDetails(this.ID);
+      this.smileyMessage = SUCCESS_MESSAGE.UPDATE_GRC_OBJECT;
+    } else {
+      this.detailsLoader = false;
+      this._getGRCObjectType();
+      this._getOwnerList();
+      this._getRCList();
+      this.getOtherGRCObjects({ rc_ids: '' });
+      // this.getOtherGRCTabCount();
+    }
+  }
+
+  private _getOwnerList() {
+    this.listObject.OWNER.isLoading = true;
+    this.apiService.getGRCOwnerList().subscribe({
+      next: (userList: any) => this.mapUserList(userList),
+      error: (error: any) => {},
+    });
+  }
+
+  /**
+   * The function `mapUserList` maps the user list data and performs some additional operations on each
+   * user object.
+   * @param {any} userList - The `userList` parameter is an object that contains a `data` property. The
+   * `data` property is an array of user objects.
+   */
+  private mapUserList(userList: any) {
+    this.listObject['OWNER']['data'] = {};
+    this.listObject['OWNER'].selectedData = [];
+    this.disabledIds = [];
+    // Map will get remove once API change
+    this.listObject['OWNER']['data']['assigneesList'] = userList?.data.map(
+      (user: any) => {
+        user.item_name = user.member_name;
+        user.employee_name = user.member_name;
+        user.my_member_id = user.member_id;
+        user.item_id = user.member_id;
+        if (['ADMIN', 'KEY_ADMIN'].includes(user.user_role)) {
+          this.disabledIds.push(user.member_id);
+          this.listObject['OWNER'].selectedData.push(user);
+        }
+        return user;
+      }
+    );
+    if (this.MODE === 'EDIT') {
+      this.listObject.OWNER.selectedData = this.listObject['OWNER']['data'][
+        'assigneesList'
+      ].filter((item: any) => this.grcPayload.owners.includes(item?.member_id));
+      this.listObject['OWNER'].disabledIds = [...new Set(this.disabledIds)];
+    } else {
+      this.defaultSelectedUser();
+    }
+    this.listObject.OWNER.isLoading = false;
+    this.checkIsDataLoaded();
+  }
+
+  /**
+   * The function `defaultSelectedUser()` sets the default selected user based on the current user's role
+   * and assigns it to the `OWNER` list object.
+   */
+  private defaultSelectedUser() {
+    if (!this.authService.isAdmin() && !this.authService.isKeyAdmin()) {
+      const USER = this.listObject['OWNER']['data']['assigneesList'].find(
+        (user: any) => user.member_id === this.authService.getMemberId()
+      );
+      this.listObject['OWNER'].selectedData.push(USER);
+    }
+    this.listObject['OWNER']['disabledIds'] = [...this.disabledIds];
+    this.grcPayload.owners = this.listObject['OWNER'].selectedData.map(
+      (user: any) => user.member_id
+    );
+  }
+
+  private _getRCList() {
+    this.listObject.RC.isLoading = true;
+    this.apiService.getResponsibilityCenterList().subscribe((data: any) => {
+      this.listObject['RC']['data'] = data;
+      this.listObject.RC.isLoading = false;
+      if (this.MODE === 'EDIT') {
+        this.listObject.RC.selectedData = data.filter((item: any) =>
+          this.grcPayload.rc_ids.includes(item?._id)
+        );
+      }
+      this.checkIsDataLoaded();
+    });
+  }
+
+  private _getGRCObjectType() {
+    this.apiService.getObjectType().subscribe({
+      next: (data: GRCType[]) => {
+        // this.setLinkRiskTab(data);
+        const OBJECT_LABEL: any = {
+          ASSETS: 'Asset',
+          PROCESSES: 'Process',
+          VENDORS: 'Vendor',
+          INVENTORY: 'Inventory',
+        };
+        this.OBJECT_TYPE = data.map((item: any, index: number) => {
+          item.value = index;
+          item.label = OBJECT_LABEL[item?.label?.toUpperCase()] ?? item?.label;
+          return item;
+        });
+
+        this.ORIGINAL_GRC_ATTRIBUTES = JSON.parse(
+          JSON.stringify(this.OBJECT_TYPE)
+        );
+
+        if (this.MODE === 'EDIT') {
+          this.OBJECT_TYPE[this.grcType].attributes =
+            this.grcPayload.attributes;
+
+          if (
+            this.grcService.checkAttributesSelected(
+              this.OBJECT_TYPE[this.grcType].attributes
+            )
+          ) {
+            this.grcForm.grcObjectType = true;
+            this.additionalOption.ATTRIBUTES = true;
+            this.populateOptionalFields();
+          }
+        }
+        this.setDefaultGRCObjectType();
+        this.checkIsDataLoaded();
+      },
+      error: (error: any) => {},
+    });
+  }
+
+  private setDefaultGRCObjectType() {
+    this.selectedAttributes =
+      this.OBJECT_TYPE.find((ele: any) => ele.value === this.grcType) ??
+      this.OBJECT_TYPE[0];
+  }
+
+  private checkIsDataLoaded() {
+    this.isLoading =
+      this.listObject.OWNER.isLoading ||
+      this.listObject.RC.isLoading ||
+      this.listObject.OTHER_GRC_OBJECTS.isLoading ||
+      (this.MODE === 'EDIT' && this.detailsLoader);
+  }
+
+  getOtherGRCObjects(event?: any) {
+    if (this.otherGRCSubscription) {
+      this.otherGRCSubscription.unsubscribe();
+    }
+    if (event?.searchString && this.otherGRCSearch !== event?.searchString) {
+      this.getOtherGRCTabCount(event);
+    }
+    this.otherGRCSearch = event?.searchString ?? '';
+    this.listObject.OTHER_GRC_OBJECTS.isLoading = true;
+    // event['rc_ids'] = this.listObject?.RC?.selectedData
+    //   ?.map((rc: any) => rc?._id)
+    //   .join(',');
+    this.otherGRCSubscription = this.grcService
+      .getGRCList(event)
+      .subscribe((data: any) => {
+        this.listObject.OTHER_GRC_OBJECTS.data = data;
+        this.listObject.OTHER_GRC_OBJECTS.isLoading = 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();
+          }
+        }
+        this.checkIsDataLoaded();
+      });
+  }
+
+  getOtherGRCTabCount(event?: any) {
+    this.grcTabLoader = true;
+    // event['rc_ids'] = this.listObject?.RC?.selectedData
+    //   ?.map((rc: any) => rc?._id)
+    //   .join(',');
+    this.grcService.getGRCTabsCount(event).subscribe((data: any) => {
+      this.grcTabLoader = false;
+      this.otherGRCCard[0].count = data?.assets_type_count;
+      this.otherGRCCard[1].count = data?.processes_type_count;
+      this.otherGRCCard[2].count = data?.vendors_type_count;
+      this.otherGRCCard[3].count = data?.inventory_type_count;
+    });
+  }
+
+  getOtherGRCTabIndex(event?: any, data?: any) {}
+
+  //Populate/Edit GRC Object
+
+  getGRCObjectDetails(grcId: string) {
+    this.apiService.getGRCObjectDetails(grcId).subscribe({
+      next: (data: any) => {
+        this.openedPopup = '';
+        this.populatePayload(data);
+        this.createGRCObject(data?.linkedGrcDetails);
+        this.detailsLoader = false;
+
+        this._getRCList();
+        this._getOwnerList();
+        this._getGRCObjectType();
+        this.getOtherGRCObjects({ rc_ids: '' });
+      },
+      error: (error: any) => {
+        console.error('error', error);
+      },
+    });
+  }
+
+  private createGRCObject(data: any) {
+    if (data?.length) {
+      this.grcForm.otherGrcObjects = true;
+      this.additionalOption.OTHER_GRC_OBJECTS = true;
+      let GRCObject: any = {
+        assets: [],
+        processes: [],
+        vendors: [],
+        inventory: [],
+      };
+      this.listObject.OTHER_GRC_OBJECTS.selectedData = [...new Set(data)];
+      const GRC_TYPE = GRC_TYPE_ARRAY;
+      data.forEach((item: any) => {
+        GRCObject[GRC_TYPE[item?.type ?? 1]].push(item);
+        this.otherGRCCard[item?.type].selectedCount += 1;
+      });
+
+      this.grcDataWithTypes = GRCObject;
+      this.updateOtherGRCObjectsPayload();
+    }
+  }
+  private populatePayload(data: any) {
+    this.grcPayload.name = data?.name;
+    this.grcPayload.type = data?.type;
+    this.grcPayload.owners = data?.owners;
+    this.grcPayload.rc_ids = data?.rc_ids;
+    this.grcPayload.linked_GRC_ids = data?.linked_GRC_ids;
+    this.grcPayload.risk_category_ids =
+      this.populateLinkRisk(data?.risk_category_ids) ?? [];
+    this.grcPayload.program_category_ids = data?.program_category_ids?.length
+      ? this.populateLinkResponsibility(data?.program_category_ids)
+      : [];
+    this.grcPayload.attributes = data?.attributes;
+    this.grcPayload.state = data?.state;
+    this.grcPayload.description = data?.description;
+    this.grcPayload.frequency = data?.frequency;
+    this.grcPayload.parent_grc_ids = data?.parent_grc_ids;
+    this.grcPayload.email_notification_member_ids =
+      data?.email_notification_member_ids;
+  }
+
+  public saveGRCObject() {
+    this.isFormSubmitted = true;
+    if (this.grcForm.grcObjectType) {
+      this.grcPayload.attributes = this.selectedAttributes.attributes;
+    }
+    if (
+      this.grcService.checkValidation(
+        this.grcPayload,
+        this.grcForm.grcObjectType
+      )
+    ) {
+      this.isLoading = true;
+      this.uiKitService.isLoader = true;
+      if (this.MODE === 'EDIT') {
+        this.updateGRCObject();
+        return;
+      }
+      let PAYLOAD = JSON.parse(JSON.stringify(this.grcPayload));
+      PAYLOAD.owners = this.getOwnersExceptDefault(PAYLOAD.owners);
+      this.apiService.addGRCObject(PAYLOAD).subscribe({
+        next: (data: any) => {
+          this.showSmiley = true;
+          this.setMoreOptionsOnSubmit();
+          this.uiKitService.isSmileyOn = true;
+          this.addedGRC = data;
+        },
+        error: (error: any) => {
+          this.isLoading = false;
+          console.error('error', error, error.status);
+          if (error.status === 409 || error.status === 403) {
+            this.isDuplicateName = true;
+            this.setMoreOptionsOnSubmit();
+            this.mapUserList({
+              data: this.listObject.OWNER.data.assigneesList,
+            });
+            this.grcNameValidationError = VALIDATION_MESSAGE.grc_exists;
+          }
+        },
+      });
+    } else {
+      return;
+    }
+  }
+
+  resetGRCObject() {
+    this.MODE = 'CREATE';
+    this.smileyMessage = SUCCESS_MESSAGE.ADD_GRC_OBJECT;
+    this.grcPayload = JSON.parse(JSON.stringify(this.grcService.GRC_PAYLOAD));
+    this.grcPayload.type = this.grcType;
+    this.isFormSubmitted = false;
+    this.isDuplicateName = false;
+    this.uiKitService.isSmileyOn = false;
+    this.hideElementsFromMoreOptions.emit(this.hideMoreOption);
+    this.OBJECT_TYPE = JSON.parse(JSON.stringify(this.ORIGINAL_GRC_ATTRIBUTES));
+    this.otherGRCCard = JSON.parse(JSON.stringify(OTHER_GRC_CARD));
+    this.resetOtherGRCCard();
+    this.setDefaultGRCObjectType();
+    this.resetGRCDataWithTypes();
+    this.resetListObjectSelection();
+    this.mapUserList({ data: this.listObject.OWNER.data.assigneesList });
+  }
+
+  resetListObjectSelection() {
+    this.listObject.OWNER.selectedData = [];
+    this.listObject.RC.selectedData = [];
+    this.listObject.OTHER_GRC_OBJECTS.selectedData = [];
+    this.listObject.RISK_CATEGORY.selectedData = [];
+    this.listObject.PROGRAM_RESPONSIBILITY.selectedData = [];
+  }
+
+  smileyActions(event: any) {
+    this.showSmiley = false;
+    this.isLoading = false;
+    if (event === 'addMore') {
+      this.resetGRCForm();
+    } else if (event === 'view') {
+      this.resetGRCForm();
+      this.viewGRC();
+    }
+  }
+
+  closeSmiley(event: any) {
+    this.showSmiley = false;
+    this.isLoading = false;
+    this.uiKitService.isSmileyOn = false;
+    this.resetGRCForm();
+    this.closeWorkflow.emit({ evt: this.addedGRC, confirm: false });
+  }
+
+  resetGRCForm() {
+    this.MODE = 'CREATE';
+    this.resetGRCObject();
+    this.grcForm.otherGrcObjects = false;
+    this.grcForm.linkRisk = false;
+    this.grcForm.linkProgram = false;
+    this.grcForm.grcObjectType = false;
+
+    this.resetForm.emit(true);
+  }
+
+  viewGRC() {
+    let url: string;
+    this.disconnectRefresh.emit(false);
+    if (window.location.host.startsWith('localhost')) {
+      url = 'http://' + window.location.host + '/#/manage-grc-objects';
+    } else {
+      url =
+        'https://' +
+        window.location.host +
+        '/organization/#/manage-grc-objects';
+    }
+
+    if (this.MODE !== 'EDIT') {
+      window.location.href = url;
+    }
+    this.resetGRCForm();
+    this.closeSmiley('');
+    this.closeWorkflow.emit({ evt: this.addedGRC, confirm: false });
+  }
+
+  setOtherGRCTypesFormate() {
+    const grcTypes = GRC_TYPE_ARRAY;
+    this.resetGRCDataWithTypes();
+    this.listObject?.OTHER_GRC_OBJECTS?.selectedData?.forEach((item: any) => {
+      this.grcDataWithTypes[grcTypes[item?.type]]?.push(item);
+    });
+    this.updateOtherGRCObjectsPayload();
+  }
+
+  removeOtherGRCObjects(event: any) {
+    const grcTypes = GRC_TYPE_ARRAY;
+    this.listObject.OTHER_GRC_OBJECTS.selectedData =
+      this.listObject.OTHER_GRC_OBJECTS.selectedData.filter(
+        (grc: any) => grc?._id !== event?._id
+      );
+    this.filterOtherGRCData(event, grcTypes[event?.type]);
+    this.otherGRCCard[0].selectedCount
+      ? (this.otherGRCCard[event?.type].selectedCount -= 1)
+      : 0;
+    this.updateOtherGRCObjectsPayload();
+  }
+
+  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: [],
+    };
+  }
+
+  get grcValidationCheck() {
+    if (this.isFormSubmitted && !this.grcPayload.name) {
+      this.grcNameValidationError = VALIDATION_MESSAGE.grcObjectName;
+    }
+    return (
+      this.isFormSubmitted && !(this.grcPayload.name || this.isDuplicateName)
+    );
+  }
+
+  getRiskCategoryPayload(selectedData: any) {
+    const riskCategoryPayload: any = [];
+    this.selectedRisks = [];
+    this.selectedCategories = [];
+    selectedData.forEach((item: any) => {
+      riskCategoryPayload.push({
+        category_id: [item?.category?.category_id ?? []],
+        risk_ids: item?.risks?.map((risk: any) => risk?.RiskId),
+      });
+      this.selectedRisks?.push(...item?.risks);
+      this.selectedCategories.push(item?.category);
+    });
+    return riskCategoryPayload;
+  }
+
+  getProgramResponsibilityPayload(selectedData: any) {
+    const riskResponsibilityPayload: any = [];
+    this.selectedResponsibility = [];
+    this.selectedProgram = [];
+    selectedData.forEach((item: any) => {
+      const parentId = item?.program?.programId;
+      riskResponsibilityPayload.push({
+        parentId: parentId,
+        category_id: [...item?.category] || [],
+        responsibility_ids: item?.responsibility?.map(
+          (resp: any) => resp?.ReportId
+        ),
+      });
+      this.selectedResponsibility?.push(...item?.responsibility);
+      this.selectedProgram.push(item?.program);
+    });
+    return riskResponsibilityPayload;
+  }
+
+  updateGRCObject() {
+    let PAYLOAD = JSON.parse(JSON.stringify(this.grcPayload));
+    PAYLOAD.owners = this.getOwnersExceptDefault(PAYLOAD.owners);
+    this.apiService.updateGRCObject(PAYLOAD, this.ID).subscribe({
+      next: (data: any) => {
+        this.showSmiley = true;
+        this.setMoreOptionsOnSubmit();
+        this.uiKitService.isSmileyOn = true;
+        this.addedGRC = data;
+      },
+      error: (error: any) => {
+        this.isLoading = false;
+        console.error('error', error, error.status);
+        if (error.status === 409) {
+          this.isDuplicateName = true;
+          this.setMoreOptionsOnSubmit();
+          this.grcNameValidationError = VALIDATION_MESSAGE.grc_exists;
+        }
+      },
+    });
+  }
+  updateOtherGRCObjectsPayload() {
+    this.grcPayload.linked_GRC_ids =
+      this.listObject.OTHER_GRC_OBJECTS.selectedData.map(
+        (item: any) => item._id
+      );
+  }
+
+  deleteSelectedRisk(categoryId: number, risk: any) {
+    const categoryIndex = this.findCheckedCategoryIndex(categoryId);
+    if (categoryIndex !== -1) {
+      // Category exists, update risk value
+      const riskIndex = this.listObject?.RISK_CATEGORY?.selectedData[
+        categoryIndex
+      ]?.risks?.findIndex((item: any) => item?._id === risk?._id);
+      if (riskIndex !== -1) {
+        this.listObject?.RISK_CATEGORY?.selectedData[
+          categoryIndex
+        ]?.risks.splice(riskIndex, 1);
+      }
+
+      if (
+        this.listObject?.RISK_CATEGORY?.selectedData[categoryIndex]?.risks
+          ?.length === 0
+      ) {
+        // Remove category if selectedListData is empty
+        this.listObject?.RISK_CATEGORY?.selectedData.splice(categoryIndex, 1);
+      }
+    }
+    this.grcPayload.risk_category_ids = this.getRiskCategoryPayload(
+      this.listObject?.RISK_CATEGORY?.selectedData
+    );
+  }
+
+  deleteSelectedResponsibility(responsibility: any) {
+    this.listObject.PROGRAM_RESPONSIBILITY.selectedData =
+      this.listObject?.PROGRAM_RESPONSIBILITY?.selectedData?.map(
+        (data: any) => {
+          let filteredResponsibility = data?.responsibility?.filter(
+            (resp: any) => resp?._id !== responsibility?._id
+          );
+          return {
+            ...data,
+            responsibility: filteredResponsibility,
+            category: [
+              ...(new Set(
+                filteredResponsibility.map((obj: any) => data?.category)?.flat()
+              ) || []),
+            ],
+          };
+        }
+      );
+
+    this.listObject.PROGRAM_RESPONSIBILITY.selectedData =
+      this.listObject?.PROGRAM_RESPONSIBILITY?.selectedData.filter(
+        (data: any) => {
+          return data?.responsibility?.length > 0;
+        }
+      );
+    this.grcPayload.program_category_ids = this.getProgramResponsibilityPayload(
+      this.listObject?.PROGRAM_RESPONSIBILITY?.selectedData
+    );
+  }
+
+  findCheckedCategoryIndex(categoryId: number | number[]) {
+    let categoryIndex = -1;
+    if (Array.isArray(categoryId) && categoryId?.length === 0) {
+      // Handle empty categoryId array case
+      const uncategorizedIndex =
+        this.listObject?.RISK_CATEGORY?.selectedData.findIndex(
+          (cat: any) => cat?.category?._id === 'uncategorized'
+        );
+      if (uncategorizedIndex !== -1) {
+        return uncategorizedIndex;
+      }
+    } else {
+      categoryIndex = this.listObject?.RISK_CATEGORY?.selectedData.findIndex(
+        (cat: any) => cat?.category?.category_id === categoryId
+      );
+    }
+    return categoryIndex;
+  }
+
+  setLinkRiskTab(tabDetails: any) {
+    this.otherGRCCard = tabDetails.map((tab: any, index: number) => {
+      return {
+        title: tab?.label,
+        count: 0,
+        selectedCount: 0,
+        key: tab?.label?.toLowerCase(),
+        type: index,
+      };
+    });
+    this.getOtherGRCTabCount({ rc_ids: '' });
+  }
+
+  populateLinkRisk(selectedData: any) {
+    let updatedData = selectedData?.map((data: any) => {
+      if (data?.category_id && Object?.keys(data?.category_id)?.length === 0) {
+        return {
+          ...data,
+          category: UNCATEGORIZED_LINK_CATEGORY,
+        };
+      }
+      return {
+        ...data,
+        category: {
+          category_id: data?.category_id[0],
+        },
+      };
+    });
+    if (updatedData.length) {
+      this.grcForm.linkRisk = true;
+      this.additionalOption.LINK_RISK_CATEGORIES_RISKS = true;
+      this.populateOptionalFields();
+    }
+    this.listObject.RISK_CATEGORY.selectedData = updatedData;
+    return this.getRiskCategoryPayload(updatedData);
+  }
+
+  populateLinkResponsibility(selectedData: any) {
+    let updatedData = selectedData?.map((data: any) => {
+      return {
+        program: {
+          programId: data?.parentId,
+        },
+        category: [data?.parentId].concat.apply(
+          [],
+          Object.values(data?.category_id)
+        ),
+        responsibility: data?.responsibility_ids || [],
+      };
+    });
+    if (updatedData.length) {
+      this.grcForm.linkProgram = true;
+      this.additionalOption.LINK_PROGRAM = true;
+      this.populateOptionalFields();
+    }
+    this.listObject.PROGRAM_RESPONSIBILITY.selectedData = updatedData;
+    return this.getProgramResponsibilityPayload(updatedData);
+  }
+
+  getOwnersExceptDefault(users: any) {
+    const usersId = users.filter(
+      (user: any) => !this.disabledIds.includes(user)
+    );
+    return usersId || [];
+  }
+
+  setMoreOptionsOnSubmit() {
+    this.isLoading = false;
+    this.uiKitService.isLoader = false;
+  }
+
+  resetOtherGRCCard() {
+    this.otherGRCCard.forEach((tab: any) => {
+      tab.count = 0;
+      tab.selectedCount = 0;
+    });
+  }
+
+  resetDataOnRCChange() {
+    this.listObject.PROGRAM_RESPONSIBILITY.selectedData = [];
+    this.listObject.RISK_CATEGORY.selectedData = [];
+    if (this.listObject.RC.selectedData.length === 0) {
+      this.resetMoreOptionsOnRCChange();
+    }
+  }
+
+  resetMoreOptionsOnRCChange() {
+    this.grcForm.linkProgram = false;
+    this.additionalOption.LINK_PROGRAM = false;
+    this.grcForm.linkRisk = false;
+    this.additionalOption.LINK_RISK_CATEGORIES_RISKS = false;
+    this.populateOptionalFields();
+  }
+}