success: function()

in src/api.js [1417:1505]
83 lines of code
26 McCabe index (conditional complexity)

            success: function (data) {
              if(++pollTimes < connect.VoiceIdConstants.EVALUATION_MAX_POLL_TIMES) {
                if(data.StreamingStatus === connect.VoiceIdStreamingStatus.PENDING_CONFIGURATION) {
                  setTimeout(evaluate, connect.VoiceIdConstants.EVALUATION_POLLING_INTERVAL);
                } else {
                  if(!data.AuthenticationResult) {
                    data.AuthenticationResult = {};
                    data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.NOT_ENABLED;
                  }

                  if(!data.FraudDetectionResult) {
                    data.FraudDetectionResult = {};
                    data.FraudDetectionResult.Decision = connect.ContactFlowFraudDetectionDecision.NOT_ENABLED;
                  }

                  // Resolve if both authentication and fraud detection are not enabled.
                  if(!self.isAuthEnabled(data.AuthenticationResult.Decision) && 
                    !self.isFraudEnabled(data.FraudDetectionResult.Decision)) {
                      connect.getLog().info("evaluateSpeaker succeeded").withObject(data).sendInternalLogToServer();
                      resolve(data);
                      return;
                  }

                  if(data.StreamingStatus === connect.VoiceIdStreamingStatus.ENDED) {
                    if(self.isAuthResultNotEnoughSpeech(data.AuthenticationResult.Decision)) {
                      data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.INCONCLUSIVE;
                    }
                    if(self.isFraudResultNotEnoughSpeech(data.FraudDetectionResult.Decision)) {
                      data.FraudDetectionResult.Decision = connect.ContactFlowFraudDetectionDecision.INCONCLUSIVE;
                    }
                  }
                  // Voice print is not long enough for both authentication and fraud detection
                  if(self.isAuthResultInconclusive(data.AuthenticationResult.Decision) &&
                    self.isFraudResultInconclusive(data.FraudDetectionResult.Decision)) {
                      connect.getLog().info("evaluateSpeaker succeeded").withObject(data).sendInternalLogToServer();
                      resolve(data);
                      return;
                  }

                  if(!self.isAuthResultNotEnoughSpeech(data.AuthenticationResult.Decision) && 
                    self.isAuthEnabled(data.AuthenticationResult.Decision)) {
                    switch (data.AuthenticationResult.Decision) {
                      case connect.VoiceIdAuthenticationDecision.ACCEPT:
                        data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.AUTHENTICATED;
                        break;
                      case connect.VoiceIdAuthenticationDecision.REJECT:
                        data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.NOT_AUTHENTICATED;
                        break;
                      case connect.VoiceIdAuthenticationDecision.SPEAKER_OPTED_OUT:
                        data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.OPTED_OUT;
                        break;
                      case connect.VoiceIdAuthenticationDecision.SPEAKER_NOT_ENROLLED:
                        data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.NOT_ENROLLED;
                        break;
                      default:
                        data.AuthenticationResult.Decision = connect.ContactFlowAuthenticationDecision.ERROR;
                    }
                  }

                  if(!self.isFraudResultNotEnoughSpeech(data.FraudDetectionResult.Decision) && 
                    self.isFraudEnabled(data.FraudDetectionResult.Decision)) {
                    switch (data.FraudDetectionResult.Decision) {
                      case connect.VoiceIdFraudDetectionDecision.HIGH_RISK:
                        data.FraudDetectionResult.Decision = connect.ContactFlowFraudDetectionDecision.HIGH_RISK;
                        break;
                      case connect.VoiceIdFraudDetectionDecision.LOW_RISK:
                        data.FraudDetectionResult.Decision = connect.ContactFlowFraudDetectionDecision.LOW_RISK;
                        break;
                      default:
                        data.FraudDetectionResult.Decision = connect.ContactFlowFraudDetectionDecision.ERROR;
                    }
                  }

                  if(!self.isAuthResultNotEnoughSpeech(data.AuthenticationResult.Decision) &&
                    !self.isFraudResultNotEnoughSpeech(data.FraudDetectionResult.Decision)) {
                      // Resolve only when both authentication and fraud detection have results. Otherwise, keep polling.
                      connect.getLog().info("evaluateSpeaker succeeded").withObject(data).sendInternalLogToServer();
                      resolve(data);
                      return;
                  } else {
                    setTimeout(evaluate, connect.VoiceIdConstants.EVALUATION_POLLING_INTERVAL);
                  }
                }
              } else {
                connect.getLog().error("evaluateSpeaker timeout").sendInternalLogToServer();
                var error = connect.VoiceIdError(connect.VoiceIdErrorTypes.EVALUATE_SPEAKER_TIMEOUT, "evaluateSpeaker timeout");
                reject(error);
              }
            },