async configureSubscription()

in source/console/src/views/Client.tsx [235:365]
104 lines of code
24 McCabe index (conditional complexity)

  async configureSubscription(subscriptionType: ClientSubscriptionTypes, delayMS: number = 10): Promise<void> {
    try {
      switch (subscriptionType) {
        case ClientSubscriptionTypes.CREATE_ISSUE:
          if (this.createIssueSubscription) { this.createIssueSubscription.unsubscribe(); }

          // @ts-ignore
          this.createIssueSubscription = API.graphql(graphqlOperation(onCreateIssue)).subscribe({
            next: (response: any) => {
              const { issues, selectedSite, selectedArea, selectedProcess, selectedStation, selectedDevice } = this.state;
              let { events } = this.state;
              const newIssue = response.value.data.onCreateIssue;
              const updatedIssues = [...issues, newIssue];

              if (selectedSite.name === newIssue.siteName && selectedArea.name === newIssue.areaName
                && selectedProcess.name === newIssue.processName && selectedStation.name === newIssue.stationName
                && selectedDevice.name === newIssue.deviceName) {
                events.filter((event: IEvent) => event.id === newIssue.eventId)
                  .forEach((event: IEvent) => {
                    event.isActive = true;
                    event.activeIssueId = newIssue.id;
                    event.updateIssueVersion = newIssue.version;
                    event.createIssueTime = newIssue.created;
                    event.createIssueTimeUtc = newIssue.createdAt;
                    event.isOpen = true;
                    event.isAcknowledged = false;
                    event.isClosedRejected = false;
                    event.issueAdditionalDetails = newIssue.additionalDetails;

                    this.processingEvents = this.processingEvents.filter(processingEvent => processingEvent.id !== event.id);
                  });
              }

              this.setState({
                issues: updatedIssues,
                events
              });
            },
            error: async (e: any) => {
              await handleSubscriptionError(e, subscriptionType, this.configureSubscription, delayMS);
            }
          });
          break;
        case ClientSubscriptionTypes.DELETE_ISSUE:
          if (this.deletePermissionSubscription) { this.deletePermissionSubscription.unsubscribe(); }

          // @ts-ignore
          this.deletePermissionSubscription = API.graphql(graphqlOperation(onDeletePermission)).subscribe({
            next: (response: any) => {
              const newPermission = response.value.data.onDeletePermission;

              if (this.userId === newPermission.userId) {
                this.refreshPermission(EMPTY_PERMISSION);
              }
            },
            error: async (e: any) => {
              await handleSubscriptionError(e, subscriptionType, this.configureSubscription, delayMS);
            }
          });
          break;
        case ClientSubscriptionTypes.PUT_PERMISSION:
          if (this.putPermissionSubscription) { this.putPermissionSubscription.unsubscribe(); }

          // @ts-ignore
          this.putPermissionSubscription = API.graphql(graphqlOperation(onPutPermission)).subscribe({
            next: (response: any) => {
              const putPermission = response.value.data.onPutPermission;

              if (this.userId === putPermission.userId) {
                this.refreshPermission(putPermission);
              }
            },
            error: async (e: any) => {
              await handleSubscriptionError(e, subscriptionType, this.configureSubscription, delayMS);
            }
          });
          break;
        case ClientSubscriptionTypes.UPDATE_ISSUE:
          if (this.updateIssueSubscription) { this.updateIssueSubscription.unsubscribe(); }
          // @ts-ignore
          this.updateIssueSubscription = API.graphql(graphqlOperation(onUpdateIssue)).subscribe({
            next: (response: any) => {
              const { issues, selectedSite, selectedArea, selectedProcess, selectedStation, selectedDevice } = this.state;
              let { events } = this.state;
              const updatedIssue = response.value.data.onUpdateIssue;
              const issueIndex = issues.findIndex(issue => issue.id === updatedIssue.id);
              const updatedIssues = [
                ...issues.slice(0, issueIndex),
                updatedIssue,
                ...issues.slice(issueIndex + 1)
              ];

              if (selectedSite.name === updatedIssue.siteName && selectedArea.name === updatedIssue.areaName
                && selectedProcess.name === updatedIssue.processName && selectedStation.name === updatedIssue.stationName
                && selectedDevice.name === updatedIssue.deviceName) {
                events.filter((event: IEvent) => event.id === updatedIssue.eventId)
                  .forEach((event: IEvent) => {
                    if (['closed', 'rejected'].includes(updatedIssue.status)) {
                      event.isActive = false;
                      event.isAcknowledged = false;
                      event.isClosedRejected = true;
                      event.activeIssueId = '';
                      delete event.createIssueTimeUtc;
                      event.isOpen = false;
                    } else if (updatedIssue.status === 'acknowledged') {
                      event.updateIssueVersion = updatedIssue.version;
                      event.createIssueTime = updatedIssue.created;
                      delete event.createIssueTimeUtc;
                      event.isAcknowledged = true;
                      event.isOpen = false;
                    }

                    this.processingEvents = this.processingEvents.filter(processingEvent => processingEvent.id !== event.id);
                  });
              }

              this.setState({
                issues: updatedIssues,
                events
              });
            },
            error: async (e: any) => {
              await handleSubscriptionError(e, subscriptionType, this.configureSubscription, delayMS);
            }
          });
          break;
      }
    } catch (err) {
      console.error('Unable to configure subscription', err);
    }
  }