intercept<BodyType> method

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

Handles chopper request and creates alice http call

Implementation

@override
FutureOr<Response<BodyType>> intercept<BodyType>(
  Chain<BodyType> chain,
) async {
  final int requestId = getRequestHashCode(
    /// The alice_token header is added to the request in order to keep track
    /// of the request in the AliceCore instance.
    applyHeader(chain.request, 'alice_token', const Uuid().v4()),
  );

  aliceCore.addCall(
    AliceHttpCall(requestId)
      ..method = chain.request.method
      ..endpoint =
          chain.request.url.path.isEmpty ? '/' : chain.request.url.path
      ..server = chain.request.url.host
      ..secure = chain.request.url.scheme == 'https'
      ..uri = chain.request.url.toString()
      ..client = 'Chopper'
      ..request =
          (AliceHttpRequest()
            ..size = switch (chain.request.body) {
              dynamic body when body is String => utf8.encode(body).length,
              dynamic body when body is List<int> => body.length,
              dynamic body when body == null => 0,
              _ => utf8.encode(body.toString()).length,
            }
            ..body = chain.request.body ?? ''
            ..time = DateTime.now()
            ..headers = chain.request.headers
            ..contentType =
                chain.request.headers[HttpHeaders.contentTypeHeader] ??
                'unknown'
            ..formDataFields =
                chain.request.parts
                    .whereType<PartValue>()
                    .map(
                      (field) => AliceFormDataField(field.name, field.value),
                    )
                    .toList()
            ..formDataFiles =
                chain.request.parts
                    .whereType<PartValueFile>()
                    .map((file) => AliceFormDataFile(file.value, "", 0))
                    .toList()
            ..queryParameters = chain.request.parameters)
      ..response = AliceHttpResponse(),
  );

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

    aliceCore.addResponse(
      AliceHttpResponse()
        ..status = response.statusCode
        ..body = response.body ?? ''
        ..size = switch (response.body) {
          dynamic body when body is String => utf8.encode(body).length,
          dynamic body when body is List<int> => body.length,
          dynamic body when body == null => 0,
          _ => utf8.encode(body.toString()).length,
        }
        ..time = DateTime.now()
        ..headers = <String, String>{
          for (final MapEntry<String, String> entry
              in response.headers.entries)
            entry.key: entry.value,
        },
      requestId,
    );

    if (!response.isSuccessful || response.error != null) {
      aliceCore.addError(AliceHttpError()..error = response.error, requestId);
    }

    return response;
  } catch (error, stackTrace) {
    /// Log error to Alice log
    AliceUtils.log(error.toString());

    aliceCore.addLog(
      AliceLog(
        message: error.toString(),
        level: DiagnosticLevel.error,
        error: error,
        stackTrace: stackTrace,
      ),
    );

    /// Add empty response to Alice core
    aliceCore.addResponse(AliceHttpResponse()..status = -1, requestId);

    /// Add error to Alice core
    aliceCore.addError(
      AliceHttpError()
        ..error = error
        ..stackTrace = stackTrace,
      requestId,
    );

    /// Rethrow error
    rethrow;
  }
}