dio and login functions

lib/services/api/api_links_endpoints.dart

@@ -0,0 +1,10 @@
+abstract class ApiEndpoints {
+  static const String baseUrl = 'https://syncrow.azurewebsites.net';
+  // static const String baseUrl = 'http://100.107.182.63:4001'; //Localhost
+
+////////////////////////////////////// Authentication ///////////////////////////////
+
+  static const String signUp = '$baseUrl/authentication/user/signup';
+  static const String login = '$baseUrl/authentication/user/login';
+
+}

lib/services/api/http_interceptor.dart

@@ -0,0 +1,76 @@
+import 'package:dio/dio.dart';
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'dart:async';
+import 'package:syncrow_web/services/api/network_exception.dart';
+import 'package:syncrow_web/utils/snack_bar.dart';
+import 'api_links_endpoints.dart';
+
+class HTTPInterceptor extends InterceptorsWrapper {
+  List<String> headerExclusionList = [];
+
+  List<String> headerExclusionListOfAddedParameters = [
+    ApiEndpoints.login,
+  ];
+  @override
+  void onResponse(Response response, ResponseInterceptorHandler handler) async {
+    if (await validateResponse(response)) {
+      super.onResponse(response, handler);
+    } else {
+      handler.reject(DioException(requestOptions: response.requestOptions, response: response));
+    }
+  }
+
+  @override
+  void onRequest(RequestOptions options, RequestInterceptorHandler handler) async {
+    var storage = const FlutterSecureStorage();
+    // var token = await storage.read(key: Token.loginAccessTokenKey);
+    // if (checkHeaderExclusionListOfAddedParameters(options.path)) {
+    //   options.headers.putIfAbsent(HttpHeaders.authorizationHeader, () => "Bearer $token");
+    // }
+    // options.headers['Authorization'] = 'Bearer ${'${token!}123'}';
+    super.onRequest(options, handler);
+  }
+
+  @override
+  void onError(DioException err, ErrorInterceptorHandler handler) async {
+    ServerFailure failure = ServerFailure.fromDioError(err);
+    if (failure.toString().isNotEmpty) {
+      CustomSnackBar.displaySnackBar(failure.toString());
+    }
+    var storage = const FlutterSecureStorage();
+    // var token = await storage.read(key: Token.loginAccessTokenKey);
+    // if (err.response?.statusCode == 401 && token != null) {
+    //   await AuthCubit.get(NavigationService.navigatorKey.currentContext!).logout();
+    // }
+    super.onError(err, handler);
+  }
+
+  /// Validates the response and returns true if it is successful (status code 2xx).
+  Future<bool> validateResponse(Response response) async {
+    if (response.statusCode != null) {
+      if (response.statusCode! >= 200 && response.statusCode! < 300) {
+        // If the response status code is within the successful range (2xx),
+        // return true indicating a successful response.
+        return true;
+      } else {
+        // If the response status code is not within the successful range (2xx),
+        // return false indicating an unsuccessful response.
+        return false;
+      }
+    } else {
+      // If the response status code is null, return false indicating an unsuccessful response.
+      return false;
+    }
+  }
+
+  checkHeaderExclusionListOfAddedParameters(String path) {
+    bool shouldAddHeader = true;
+
+    for (var urlConstant in headerExclusionListOfAddedParameters) {
+      if (path.contains(urlConstant)) {
+        shouldAddHeader = false;
+      }
+    }
+    return shouldAddHeader;
+  }
+}

lib/services/api/http_service.dart

@@ -0,0 +1,134 @@
+import 'package:dio/dio.dart';
+import 'package:syncrow_web/services/api/api_links_endpoints.dart';
+import 'package:syncrow_web/services/api/http_interceptor.dart';
+import 'package:syncrow_web/services/locator.dart';
+
+class HTTPService {
+  final Dio client = serviceLocator.get<Dio>();
+
+  // final navigatorKey = GlobalKey<NavigatorState>();
+
+  String certificateString = "";
+
+  static Dio setupDioClient() {
+    Dio client = Dio(
+      BaseOptions(
+        baseUrl: ApiEndpoints.baseUrl,
+        receiveDataWhenStatusError: true,
+        followRedirects: false,
+        connectTimeout: const Duration(seconds: 30),
+        receiveTimeout: const Duration(seconds: 30),
+      ),
+    );
+
+    client.interceptors.add(serviceLocator.get<HTTPInterceptor>());
+    return client;
+  }
+
+  Future<T> get<T>({
+    required String path,
+    Map<String, dynamic>? queryParameters,
+    required T Function(dynamic) expectedResponseModel,
+    bool showServerMessage = true,
+  }) async {
+    try {
+      final response = await client.get(
+        path,
+        queryParameters: queryParameters,
+      );
+      return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+
+  Future<T> post<T>(
+      {required String path,
+      Map<String, dynamic>? queryParameters,
+      Options? options,
+      dynamic body,
+      bool showServerMessage = true,
+      required T Function(dynamic) expectedResponseModel}) async {
+    try {
+      final response = await client.post(
+        path,
+        data: body,
+        queryParameters: queryParameters,
+        options: options,
+      );
+      return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+
+  Future<T> patch<T>(
+      {required String path,
+      Map<String, dynamic>? queryParameters,
+      dynamic body,
+      required T Function(dynamic) expectedResponseModel}) async {
+    try {
+      final response = await client.patch(
+        path,
+        data: body,
+        queryParameters: queryParameters,
+      );
+      return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+
+  Future<T> put<T>(
+      {required String path,
+      Map<String, dynamic>? queryParameters,
+      dynamic body,
+      required T Function(dynamic) expectedResponseModel}) async {
+    try {
+      final response = await client.put(
+        path,
+        data: body,
+        queryParameters: queryParameters,
+      );
+      return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+
+  Future<T> download<T>(
+      {required String path,
+      required String savePath,
+      Map<String, dynamic>? queryParameters,
+      required T Function(dynamic) expectedResponseModel}) async {
+    try {
+      final response = await client.download(
+        path,
+        savePath,
+        onReceiveProgress: (current, total) {},
+      );
+
+      return expectedResponseModel(response.data);
+      // return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+
+  Future<T> delete<T>({
+    required String path,
+    Map<String, dynamic>? queryParameters,
+    required T Function(dynamic) expectedResponseModel,
+    bool showServerMessage = true,
+  }) async {
+    try {
+      final response = await client.delete(
+        path,
+        queryParameters: queryParameters,
+      );
+      return expectedResponseModel(response.data);
+    } catch (error) {
+      rethrow;
+    }
+  }
+}

lib/services/api/my_http_overrides.dart

@@ -0,0 +1,11 @@
+import 'dart:io';
+
+// We use this class to skip the problem of SSL certification and solve the Image.network(url) issue
+class MyHttpOverrides extends HttpOverrides {
+  @override
+  HttpClient createHttpClient(SecurityContext? context) {
+    return super.createHttpClient(context)
+      ..badCertificateCallback =
+          (X509Certificate cert, String host, int port) => true;
+  }
+}

lib/services/api/network_exception.dart

@@ -0,0 +1,74 @@
+import 'package:dio/dio.dart';
+
+abstract class Failure {
+  final String errMessage;
+
+  Failure(this.errMessage);
+}
+
+class ServerFailure extends Failure {
+  ServerFailure(super.errMessage);
+
+  @override
+  String toString() {
+    return errMessage;
+  }
+
+  factory ServerFailure.fromDioError(DioException dioError) {
+    switch (dioError.type) {
+      case DioExceptionType.connectionTimeout:
+        return ServerFailure("Connection timeout with the Server.");
+      case DioExceptionType.sendTimeout:
+        return ServerFailure("Send timeout with the Server.");
+
+      case DioExceptionType.receiveTimeout:
+        return ServerFailure("Receive timeout with the Server.");
+
+      case DioExceptionType.badCertificate:
+        return ServerFailure("Bad certificate!");
+
+      case DioExceptionType.badResponse:
+        {
+          // var document = parser.parse(dioError.response!.data.toString());
+          // var message = document.body!.text;
+          return ServerFailure.fromResponse(
+              dioError.response!.statusCode!, dioError.response?.data['message'] ?? "Error");
+        }
+      case DioExceptionType.cancel:
+        return ServerFailure("The request to ApiServer was canceled");
+
+      case DioExceptionType.connectionError:
+        return ServerFailure("No Internet Connection");
+
+      case DioExceptionType.unknown:
+        return ServerFailure("Unexpected Error, Please try again!");
+
+      default:
+        return ServerFailure("Unexpected Error, Please try again!");
+    }
+  }
+
+  factory ServerFailure.fromResponse(int? statusCode, dynamic responseMessage) {
+    switch (statusCode) {
+      case 401:
+      case 403:
+        return ServerFailure(responseMessage);
+      case 400:
+        List<String> errors = [];
+        if (responseMessage is List) {
+          for (var error in responseMessage) {
+            errors.add(error);
+          }
+        } else {
+          return ServerFailure(responseMessage);
+        }
+        return ServerFailure(errors.join('\n'));
+      case 404:
+        return ServerFailure("");
+      case 500:
+        return ServerFailure(responseMessage);
+      default:
+        return ServerFailure("Opps there was an Error, Please try again!");
+    }
+  }
+}

lib/services/auth_api.dart

@@ -1 +1,29 @@
-class AuthAPI {}
+import 'package:syncrow_web/pages/auth/model/token.dart';
+import 'api/api_links_endpoints.dart';
+import 'api/http_service.dart';
+
+class AuthenticationAPI {
+
+
+  static Future<Token> loginWithEmail({required var model}) async {
+    final response = await HTTPService().post(
+        path: ApiEndpoints.login,
+        body: model.toJson(),
+        showServerMessage: false,
+        expectedResponseModel: (json) => Token.fromJson(json['data']));
+    return response;
+  }
+
+  // static Future<bool> signUp({required SignUpModel model}) async {
+  //   final response = await HTTPService().post(
+  //       path: ApiEndpoints.signUp,
+  //       body: model.toJson(),
+  //       showServerMessage: false,
+  //       expectedResponseModel: (json) => json['statusCode'] == 201);
+  //   return response;
+  // }
+
+
+
+
+}

lib/services/locator.dart

@@ -0,0 +1,13 @@
+import 'package:dio/dio.dart';
+import 'package:get_it/get_it.dart';
+import 'package:syncrow_web/services/api/http_interceptor.dart';
+import 'package:syncrow_web/services/api/http_service.dart';
+
+final GetIt serviceLocator = GetIt.instance;
+ //setupLocator() // to search for dependency injection in flutter
+initialSetup() {
+  serviceLocator.registerSingleton<HTTPInterceptor>(HTTPInterceptor());
+  //Base classes
+
+  serviceLocator.registerSingleton<Dio>(HTTPService.setupDioClient());
+}