Notes

lib => data => network => api_error_handle

import 'package:alanis/export.dart';
import 'package:dio/dio.dart';

class StatusCode {
static getDioException(error, context) {
if (error is Exception) {
try {
if (error is DioError) {
switch (error.type) {
case DioErrorType.CANCEL:
HelperWidget.toast(Strings.REQUEST_CANCELLED);
break;
case DioErrorType.CONNECT_TIMEOUT:
HelperWidget.toast(Strings.CONNECTION_TIMEOUT);
break;
case DioErrorType.DEFAULT:
List<String> dateParts = error.message.split(":");
List<String> message = dateParts[2].split(",");

if (message[0].trim() == Strings.connectionRefused) {
HelperWidget.toast(Strings.pleaseTryAgain);
} else if (message[0].trim() == Strings.networkUnreachable) {
HelperWidget.toast(Strings.INTERNET_CONNECTION);
} else {
HelperWidget.toast(message[0]);
}

break;
case DioErrorType.RECEIVE_TIMEOUT:
HelperWidget.toast(Strings.TIME_OUT);
break;
case DioErrorType.RESPONSE:
switch (error.response.statusCode) {
case 400:
Map<String, dynamic> data = error.response.data;

if (data.values.elementAt(0).runtimeType == String) {
HelperWidget.toast(data.values.elementAt(0));
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
HelperWidget.toast(dataValue);
} else {
HelperWidget.toast(Strings.UNAUTH_REQUEST);
}
} else {
HelperWidget.toast(datas.values.first[0]);
}
}

break;
case 401:
PrefManger.saveRegisterData(null);
HelperUtility.pushAndRemoveUntil(
route: LoginScreen(), context: context);

Map<String, dynamic> data = error.response.data;

if (data.values.elementAt(0).runtimeType == String) {
HelperWidget.toast(data.values.elementAt(0));
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
HelperWidget.toast(dataValue);
} else {
HelperWidget.toast(Strings.UNAUTH_REQUEST);
}
} else {
HelperWidget.toast(datas.values.first[0]);
}
}
break;
case 403:
PrefManger.saveRegisterData(null);
HelperUtility.pushAndRemoveUntil(
route: LoginScreen(), context: context);
Map<String, dynamic> data = error.response.data;
if (data.values.elementAt(0).runtimeType == String) {
HelperWidget.toast(data.values.elementAt(0));
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
HelperWidget.toast(dataValue);
} else {
HelperWidget.toast(Strings.UNAUTH_REQUEST);
}
} else {
HelperWidget.toast(datas.values.first[0]);
}
}
break;
case 404:
HelperWidget.toast(Strings.NOT_FOUND);
break;
case 408:
HelperWidget.toast(Strings.REQUEST_TIME_OUT);
break;
case 500:
HelperWidget.toast(Strings.INTERNAL_SERVER_ERROR);
break;
case 503:
HelperWidget.toast(Strings.INTERNET_SERVICE_UNAVAIL);
break;
default:
HelperWidget.toast(Strings.SOMETHINGS_IS_WRONG);
}
break;
case DioErrorType.SEND_TIMEOUT:
HelperWidget.toast(Strings.TIME_OUT);
break;
}
} else if (error is SocketException) {
HelperWidget.toast(Strings.SOCKET_EXCEPTIONS);
} else {
HelperWidget.toast(Strings.UNEXPECTED_EXCEPTION);
}
} on FormatException catch (_) {
HelperWidget.toast(Strings.FORMAT_EXCEPTION);
} catch (_) {
HelperWidget.toast(Strings.UNEXPECTED_EXCEPTION);
}
}
}
}


lib => data => network => api_provider

import 'package:dio/dio.dart';
import 'package:flutter_base_project/model/response_model/auth_models/change_password_response.dart';
import 'package:flutter_base_project/model/response_model/auth_models/forgot_password_response.dart';
import 'package:flutter_base_project/model/response_model/auth_models/login_response_model.dart';
import 'package:flutter_base_project/model/response_model/auth_models/logout_response_model.dart';

import 'api_error_handle.dart';
import 'constant.dart';
import 'dio_client.dart';

class APIRepository {
static DioClient dioClient;

APIRepository() {
var dio = Dio();
dioClient = DioClient(baseUrl, dio);
}

/*===================================================================== login APi Call ==========================================================*/

static Future loginApiCall(Map<String, dynamic> dataBody) async {
try {
FormData formData = FormData.fromMap(dataBody);
final response = await dioClient.post(loginEndPoint, data: formData);
return LoginResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}

/*===================================================================== register APi Call ==========================================================*/

static Future registerApiCall(Map<String, dynamic> dataBody) async {
try {
FormData formData = FormData.fromMap(dataBody);
final response = await dioClient.post(registerEndPoint, data: formData);
return LoginResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}

/*===================================================================== forgot password Call =======================================================*/

static Future forgotApiCall(Map<String, dynamic> dataBody) async {
try {
FormData formData = FormData.fromMap(dataBody);
final response =
await dioClient.post(resetPasswordEndPoint, data: formData);

return ForgotPasswordResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}

/*===================================================================== update APi Call ==========================================================*/

static Future updateProfile(
Map<String, dynamic> dataBody, int id, String accessToken) async {
try {
FormData formData = FormData.fromMap(dataBody);
final response = await dioClient.post(userUpdateEndPoint,
data: formData,
queryParameters: {'id': id, 'access-token': accessToken});
return LoginResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}

/*===================================================================== change Password APi Call ==========================================================*/

static Future changePassword(
Map<String, dynamic> dataBody, String accessToken) async {
try {
FormData formData = FormData.fromMap(dataBody);
final response = await dioClient.post(userChangePasswordEndPoint,
data: formData, queryParameters: {'access-token': accessToken});

return ChangePasswordResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}

/*===================================================================== logout APi Call ==========================================================*/

static Future logoutApiCall(String accessToken) async {
try {
final response = await dioClient
.post(userLogout, queryParameters: {'access-token': accessToken});
return LopgoutResponseModel.fromJson(response);
} on DioError catch (e) {
StatusCode.getDioException(e);
return null;
}
}
}

lib => data => network => dio_client


import 'package:dio/dio.dart';
import 'package:alanis/export.dart';

const _defaultConnectTimeout = Duration.millisecondsPerMinute;
const _defaultReceiveTimeout = Duration.millisecondsPerMinute;

class DioClient {
String baseUrl;

static Dio _dio;

final List<Interceptor> interceptors;

DioClient(
this.baseUrl,
Dio dio, {
this.interceptors,
}) {
_dio = dio ?? Dio();
_dio
..options.baseUrl = baseUrl
..options.connectTimeout = _defaultConnectTimeout
..options.receiveTimeout = _defaultReceiveTimeout
..httpClientAdapter
..options.headers = {'Content-Type': 'application/json; charset=UTF-8'};
if (interceptors?.isNotEmpty ?? false) {
_dio.interceptors.addAll(interceptors);
}
if (kDebugMode) {
_dio.interceptors.add(LogInterceptor(
responseBody: true,
error: true,
requestHeader: true,
responseHeader: false,
request: false,
requestBody: true));
}
}

Future<dynamic> get(
String uri, {
Map<String, dynamic> queryParameters,
Options options,
CancelToken cancelToken,
ProgressCallback onReceiveProgress,
}) async {
try {
var response = await _dio.get(
uri,
queryParameters: queryParameters,
options: options,
cancelToken: cancelToken,
onReceiveProgress: onReceiveProgress,
);
return response.data;
} on SocketException catch (e) {
throw SocketException(e.toString());
} on FormatException catch (_) {
throw FormatException("Unable to process the data");
} catch (e) {
throw e;
}
}

Future<dynamic> post(
String uri, {
data,
Map<String, dynamic> queryParameters,
Options options,
CancelToken cancelToken,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
try {
var response = await _dio.post(
uri,
data: data,
queryParameters: queryParameters,
options: options,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return response.data;
} on FormatException catch (_) {
throw FormatException("Unable to process the data");
} catch (e) {
throw e;
}
}

static Future<dynamic> put(
String uri, {
data,
Map<String, dynamic> queryParameters,
Options options,
CancelToken cancelToken,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
try {
var response = await _dio.put(
uri,
data: data,
queryParameters: queryParameters,
options: options,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return response.data;
} on FormatException catch (_) {
throw FormatException("Unable to process the data");
} catch (e) {
throw e;
}
}
}


lib => data => network => network_exceptions



import 'package:alanis/export.dart';
import 'package:dio/dio.dart';

class NetworkExceptions {
static String messageData = "";

static getDioException(error, context) {
if (error is Exception) {
try {
if (error is DioError) {
switch (error.type) {
case DioErrorType.CANCEL:
return messageData = Strings.REQUEST_CANCELLED;
break;
case DioErrorType.CONNECT_TIMEOUT:
return messageData = Strings.CONNECTION_TIMEOUT;
break;
case DioErrorType.DEFAULT:
List<String> dateParts = error.message.split(":");
List<String> message = dateParts[2].split(",");

if (message[0].trim() == Strings.connectionRefused) {
return messageData = Strings.serverMaintance;
} else if (message[0].trim() == Strings.networkUnreachable) {
return messageData = Strings.INTERNET_CONNECTION;
} else {
return messageData = message[0];
}

break;
case DioErrorType.RECEIVE_TIMEOUT:
return messageData = Strings.TIME_OUT;
break;
case DioErrorType.RESPONSE:
switch (error.response.statusCode) {
case 400:
Map<String, dynamic> data = error.response.data;

if (data.values.elementAt(0).runtimeType == String) {
return messageData = data.values.elementAt(0);
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
return messageData = dataValue;
} else {
return messageData = Strings.UNAUTH_REQUEST;
}
} else {
return messageData = datas.values.first[0];
}
}

break;
case 401:
PrefManger.saveRegisterData(null);
HelperUtility.pushAndRemoveUntil(
route: LoginScreen(), context: context);
Map<String, dynamic> data = error.response.data;

if (data.values.elementAt(0).runtimeType == String) {
return messageData = data.values.elementAt(0);
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
return messageData = dataValue;
} else {
return messageData = Strings.UNAUTH_REQUEST;
}
} else {
return messageData = datas.values.first[0];
}
}
break;
case 403:
PrefManger.saveRegisterData(null);
HelperUtility.pushAndRemoveUntil(
route: LoginScreen(), context: context);
Map<String, dynamic> data = error.response.data;
if (data.values.elementAt(0).runtimeType == String) {
return messageData = data.values.elementAt(0);
} else {
Map<String, dynamic> datas = data.values.elementAt(0);
if (data.values.elementAt(0) == null) {
var dataValue = ErrorMessageResponseModel.fromJson(
error.response.data)
.message;
if (dataValue == null) {
return messageData = dataValue;
} else {
return messageData = Strings.UNAUTH_REQUEST;
}
} else {
return messageData = datas.values.first[0];
}
}

break;
case 404:
return messageData = Strings.NOT_FOUND;
break;
case 408:
return messageData = Strings.REQUEST_TIME_OUT;
break;
case 500:
return messageData = Strings.INTERNAL_SERVER_ERROR;
break;
case 503:
return messageData = Strings.INTERNET_SERVICE_UNAVAIL;
break;
default:
return messageData = Strings.SOMETHINGS_IS_WRONG;
}
break;
case DioErrorType.SEND_TIMEOUT:
return messageData = Strings.TIME_OUT;
break;
}
} else if (error is SocketException) {
return messageData = Strings.SOCKET_EXCEPTIONS;
} else {
return messageData = Strings.UNEXPECTED_EXCEPTION;
}
} on FormatException catch (_) {
return messageData = Strings.FORMAT_EXCEPTION;
} catch (_) {
return messageData = Strings.UNEXPECTED_EXCEPTION;
}
}
}
}