intercept<BodyType> method

@override Future<Response<BodyType>> intercept<BodyType>(Chain<BodyType> chain)

Implementation

@override
Future<Response<BodyType>> intercept<BodyType>(Chain<BodyType> chain) async {
  final Stopwatch stopWatch = Stopwatch();

  try {
    final Request request = chain.request;

    if (settings.enabled && (settings.requestFilter?.call(request) ?? true)) {
      _talker.logCustom(
        ChopperRequestLog(
          request.url.toString(),
          request: await request.toBaseRequest(),
          settings: settings,
        ),
      );
    }

    stopWatch.start();

    final Response<BodyType> response = await chain.proceed(request);

    stopWatch.stop();

    switch (response.statusCode) {
      case int statusCode when settings.enabled && statusCode < 400:
        if (settings.responseFilter?.call(response) ?? true) {
          _talker.logCustom(
            ChopperResponseLog<BodyType>(
              response.base.request?.url.toString() ?? request.url.toString(),
              settings: settings,
              request: request,
              response: response,
              responseTime: stopWatch.elapsedMilliseconds,
            ),
          );
        }
        break;
      case _ when settings.enabled:
        if (settings.errorFilter?.call(response) ?? true) {
          _talker.logCustom(
            ChopperErrorLog<BodyType>(
              response.error?.toString() ??
                  'HTTP Error ${response.statusCode}',
              settings: settings,
              request: request,
              exception: ChopperException(
                response.error.toString(),
                request: request,
                response: response,
              ),
              responseTime: stopWatch.elapsedMilliseconds,
            ),
          );
        }
        break;
    }

    return response;
  } catch (exception, stackTrace) {
    switch (exception) {
      case ChopperHttpException ex when settings.enabled:
        if (settings.errorFilter?.call(ex.response) ?? true) {
          _talker.logCustom(
            ChopperErrorLog<BodyType>(
              ex.toString(),
              settings: settings,
              exception: ex,
              stackTrace: stackTrace,
            ),
          );
        }
        break;
      case ChopperException ex when settings.enabled:
        if (ex.response != null &&
            (settings.errorFilter?.call(ex.response!) ?? true)) {
          _talker.logCustom(
            ChopperErrorLog<BodyType>(
              ex.message,
              settings: settings,
              exception: ex,
              stackTrace: stackTrace,
            ),
          );
        }
        break;
      case _ when settings.enabled:
        _talker.error(exception.toString(), exception, stackTrace);
        break;
    }

    rethrow;
  } finally {
    if (stopWatch.isRunning) {
      stopWatch.stop();
    }
  }
}