apiInterceptorTemplate function

String apiInterceptorTemplate()

Implementation

String apiInterceptorTemplate() {
  return '''
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:flutter/foundation.dart';
import '../constants/app_strings.dart';
import 'api_exception.dart';


class ApiInterceptor extends Interceptor {
  final LogInterceptor _logger = LogInterceptor(
    requestBody: true,
    responseBody: true,
    requestHeader: true,
    responseHeader: false,
    logPrint: (object) => debugPrint(object.toString()),
  );

  @override
  Future<void> onRequest(
    RequestOptions options,
    RequestInterceptorHandler handler,
  ) async {
    options.headers["Accept"] = "application/json";
    final token = "your auth token";
    final accessToken = "your access token";

    if (token != null) {
      options.headers['authorization'] = token;
      options.headers['accessToken'] = accessToken;
    }

    if (kDebugMode) {
      _logger.onRequest(options, handler);
    } else {
      // In production, just proceed silently
      handler.next(options);
    }
  }

  @override
  void onResponse(Response response, ResponseInterceptorHandler handler) {
    if (kDebugMode) {
      _logger.onResponse(response, handler);
    } else {
      handler.next(response);
    }
  }

  @override
  Future<void> onError(
    DioException err,
    ErrorInterceptorHandler handler,
  ) async {


    final message = _handleError(err);

    if (err.response?.statusCode == 403) {


    }

    handler.reject(
      DioException(
        requestOptions: err.requestOptions,
        response: err.response,
        type: err.type,
        error: ApiException(message),
      ),
    );
  }

  String _handleError(DioException error) {
    final response = error.response;
    final data = response?.data;

    final serverMessage = _extractServerMessage(data);

    if (serverMessage != null) {
      return serverMessage;
    }

    switch (error.type) {
      case DioExceptionType.connectionTimeout:
        return "Connection timeout. Please try again.";

      case DioExceptionType.sendTimeout:
        return "Request timeout. Please try again.";

      case DioExceptionType.receiveTimeout:
        return "Server is taking too long to respond.";

      case DioExceptionType.connectionError:
        if (error.error is SocketException) {
          return AppStrings.noInternet;
        }

        return "Unable to reach server.";

      case DioExceptionType.badResponse:
        final statusCode = response?.statusCode;

        switch (statusCode) {
          case 400:
            return "Invalid request.";

          case 401:
            return "Session expired. Please login again.";

          case 403:
            return "Access denied.";

          case 404:
            return "Server not found.";

          case 422:
            return "Validation error.";

          case 500:
            return "Server error. Please try again later.";

          default:
            return "Something went wrong.";
        }

      case DioExceptionType.cancel:
        return "Request cancelled.";

      default:
        return "Something went wrong.";
    }
  }

  String? _extractServerMessage(dynamic data) {
    if (data == null) return null;

    if (data is Map<String, dynamic>) {
      if (data["message"] != null) {
        return data["message"].toString();
      }

      if (data["error"] != null) {
        return data["error"].toString();
      }

      if (data["detail"] != null) {
        return data["detail"].toString();
      }

      if (data["errors"] != null) {
        final errors = data["errors"];

        if (errors is List && errors.isNotEmpty) {
          return errors.first.toString();
        }

        if (errors is Map && errors.isNotEmpty) {
          return errors.values.first.toString();
        }
      }
    }

    return null;
  }
}
''';
}