Created
January 11, 2022 10:40
-
-
Save febritecno/d5810c91532c2586dbce75d52a770d44 to your computer and use it in GitHub Desktop.
refresh token nuxtjs & flutter dio
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// onRequest(config) | |
// onResponse(response) | |
// onError(err) | |
// onRequestError(err) | |
// onResponseError(err) | |
// $axios.interceptors.response.use(res) | |
import swal from "sweetalert2"; | |
export default function ({ | |
$axios, | |
$storage, | |
redirect | |
}) { | |
// global function -------- | |
const relogin = () => { | |
$storage.removeUniversal("token"); | |
redirect("/login"); | |
setTimeout(() => { | |
swal.fire({ | |
animation: false, | |
title: "Session Expired", | |
text: "please login again", | |
type: "warning", | |
}); | |
}, 1000); | |
}; | |
// ------------------------- | |
/// Request Handler | |
$axios.onRequest((request) => { | |
try { | |
var userData = $storage.getUniversal("token"); | |
if (userData.token) { | |
request.headers.common["Authorization"] = "Bearer " + userData.token; | |
} | |
return request; | |
} catch (e) { | |
return request; | |
} | |
}); | |
/// Response handler | |
let isAlreadyFetchingAccessToken = false; | |
let subscribers = []; | |
function onAccessTokenFetched(access_token) { | |
subscribers = subscribers.filter(callback => callback(access_token)); | |
} | |
function addSubscriber(callback) { | |
subscribers.push(callback); | |
} | |
$axios.interceptors.response.use(function (response) { | |
return response; | |
}, (error) => { | |
const { | |
config, | |
response: { | |
status | |
} | |
} = error; | |
const originalRequest = config; | |
if (status === 401) { | |
if (!isAlreadyFetchingAccessToken) { | |
isAlreadyFetchingAccessToken = true; | |
const userData = $storage.getUniversal("token"); | |
const rememberToken = userData.user.remember_token ? userData.user.remember_token : ""; | |
if (rememberToken != "" || rememberToken != null) { | |
$axios.post("/api/refresh-token", { | |
remember_token: rememberToken | |
}).then(async (res) => { | |
const resData = res.data.data; | |
userData.token = resData.access_token; | |
// userData.user.remember_token = resData.remember_token; | |
$storage.setUniversal("token", userData); | |
onAccessTokenFetched(userData.token); | |
isAlreadyFetchingAccessToken = false; | |
}).catch(() => { | |
relogin(); | |
}); | |
} | |
} | |
const retryOriginalRequest = new Promise((resolve) => { | |
addSubscriber(access_token => { | |
originalRequest.headers.Authorization = 'Bearer ' + access_token; | |
resolve($axios(originalRequest)); | |
}) | |
}) | |
return retryOriginalRequest | |
} else if (status === 429 || status === 403 || status === 402) { | |
relogin(); | |
} | |
return Promise.reject(error); | |
}) | |
} |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// onRequest(config) | |
// onResponse(response) | |
// onError(err) | |
// onRequestError(err) | |
// onResponseError(err) | |
import swal from "sweetalert2"; | |
export default function ({ | |
$axios, | |
$storage, | |
redirect | |
}) { | |
$axios.onRequest(async (request) => { | |
try { | |
// middleware set up token | |
var userData = await $storage.getUniversal("token"); | |
request.headers.common["Authorization"] = "Bearer " + userData.token; | |
return request; | |
} catch (e) { | |
return request; | |
} | |
}); | |
// error status handler | |
$axios.onResponseError(({ | |
response | |
}) => { | |
const resCode = parseInt(response.status); | |
switch (resCode) { | |
case 404: | |
break; | |
case 403: | |
break; | |
case 402: | |
break; | |
case 401: | |
$storage.removeUniversal("token"); | |
redirect("/login"); | |
setTimeout(() => { | |
swal.fire({ | |
animation: false, | |
title: "Session Expired", | |
text: "please login again", | |
type: "warning", | |
}); | |
}, 1000); | |
break; | |
case 400: | |
break; | |
} | |
}); | |
} |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import 'dart:async'; | |
import 'package:dio/dio.dart'; | |
import 'package:flutter/material.dart'; | |
import 'package:kipos/config/constants/app_constants.dart'; | |
import 'package:kipos/config/helpers/app_key.dart'; | |
import 'package:kipos/config/helpers/helpers.dart'; | |
import 'package:kipos/config/helpers/system/snackbar.dart'; | |
import 'package:kipos/config/helpers/utils/connection_utils.dart'; | |
import 'package:pretty_dio_logger/pretty_dio_logger.dart'; | |
import 'api_errors/api_error_message_error.dart'; | |
import 'api_errors/bad_network_api_error.dart'; | |
import 'api_errors/internal_server_api_error.dart'; | |
import 'api_errors/unauthorized_api_error.dart'; | |
import 'exceptions/exceptions.dart'; | |
class ApiClient { | |
final Dio dio; | |
ApiClient(this.dio) { | |
dio.options.baseUrl = BASE_API_URL; | |
dio.options.headers["Authorization"] = AuthPrefs.getToken(); | |
dio.options.connectTimeout = const Duration(minutes: 3).inMilliseconds; | |
dio.options.receiveTimeout = const Duration(minutes: 3).inMilliseconds; | |
dio.interceptors.add(PrettyDioLogger( | |
requestHeader: true, | |
requestBody: true, | |
responseHeader: true, | |
responseBody: true, | |
error: true, | |
compact: true, | |
)); | |
} | |
Future getMessage(String? type) { | |
var selected; | |
switch (type) { | |
case 'no_internet': | |
AppSnackBar.dynamic( | |
seconds: 6, | |
backgroundColor: Colors.black54, | |
title: 'No Internet Connection', | |
icon: Icon(Icons.wifi_tethering_off, color: Colors.white), | |
message: 'Please check your network connection'); | |
break; | |
} | |
return selected; | |
} | |
Future<Response> post( | |
String path, | |
dynamic data, | |
) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.post(path, data: data); | |
if (response.statusCode == 401 || response.statusCode == 402) { | |
AppSnackBar.info(response.data['error']); | |
Helpers.clearToken(); | |
} | |
return response; | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
if (resError.statusCode == 401 || resError.statusCode == 402) { | |
AppSnackBar.info(resError.data['error']); | |
Helpers.clearToken(); | |
} | |
} | |
return resError; | |
} | |
} else { | |
getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future<Response> put(String path, dynamic data) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.put(path, data: data); | |
if (response.statusCode == 401 || response.statusCode == 402) { | |
AppSnackBar.info(response.data['error']); | |
Helpers.clearToken(); | |
} | |
return response; | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
if (resError.statusCode == 401 || resError.statusCode == 402) { | |
AppSnackBar.info(resError.data['error']); | |
Helpers.clearToken(); | |
} | |
} | |
return resError; | |
} | |
} else { | |
getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future<Response> delete(String path) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.delete(path); | |
if (response.statusCode == 401 || response.statusCode == 402) { | |
AppSnackBar.info(response.data['error']); | |
Helpers.clearToken(); | |
} | |
return response; | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
if (resError.statusCode == 401 || resError.statusCode == 402) { | |
AppSnackBar.info(resError.data['error']); | |
Helpers.clearToken(); | |
} | |
} | |
return resError; | |
} | |
} else { | |
getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future<Response> get(String path) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.get( | |
path, | |
options: Options( | |
followRedirects: false, | |
validateStatus: (status) { | |
return status! < 500; | |
}, | |
), | |
); | |
if (response.statusCode == 401 || response.statusCode == 402) { | |
AppSnackBar.info(response.data['error']); | |
Helpers.clearToken(); | |
} | |
return response; | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
if (resError.statusCode == 401 || resError.statusCode == 402) { | |
AppSnackBar.info(resError.data['error']); | |
Helpers.clearToken(); | |
} | |
} | |
return resError; | |
} | |
} else { | |
getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
} |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import 'dart:async'; | |
import 'package:dio/dio.dart'; | |
import 'package:flutter/material.dart'; | |
import 'package:kipos/config/constants/app_constants.dart'; | |
import 'package:kipos/config/exceptions/app_exception.dart'; | |
import 'package:kipos/config/helpers/app_key.dart'; | |
import 'package:kipos/config/helpers/helpers.dart'; | |
import 'package:kipos/config/helpers/system/snackbar.dart'; | |
import 'package:kipos/config/helpers/utils/connection_utils.dart'; | |
import 'package:pretty_dio_logger/pretty_dio_logger.dart'; | |
import 'api_errors/api_error_message_error.dart'; | |
import 'api_errors/bad_network_api_error.dart'; | |
import 'api_errors/internal_server_api_error.dart'; | |
import 'api_errors/unauthorized_api_error.dart'; | |
import 'exceptions/exceptions.dart'; | |
class ApiClient { | |
final Dio dio; | |
ApiClient(this.dio) { | |
dio.options.headers["Authorization"] = AuthPrefs.getToken(); | |
dio.options.connectTimeout = const Duration(minutes: 3).inMilliseconds; | |
dio.options.receiveTimeout = const Duration(minutes: 3).inMilliseconds; | |
dio.interceptors.addAll([ | |
PrettyDioLogger( | |
requestHeader: true, | |
requestBody: true, | |
responseHeader: true, | |
responseBody: true, | |
error: true, | |
compact: true, | |
), | |
]); | |
} | |
/// handle refresh token | |
Future<void> _refreshToken() async { | |
final refreshToken = AuthPrefs.getRememberToken(); | |
await dio.post(BASE_API_URL + "/refresh-token", | |
data: {'remember_token': refreshToken}).then((response) { | |
String getBearerToken = 'Bearer ${response.data['data']['access_token']}'; | |
AuthPrefs.setToken(getBearerToken); | |
}); | |
} | |
Future<Future<Response>> _retry(RequestOptions requestOptions) async { | |
dio.options.headers["Authorization"] = AuthPrefs.getToken(); | |
final options = new Options( | |
method: requestOptions.method, | |
); | |
return dio.request<dynamic>(requestOptions.path, | |
data: requestOptions.data, | |
queryParameters: requestOptions.queryParameters, | |
options: options); | |
} | |
/// handle response | |
Future<Object> _handleResponse(Response response) async { | |
try { | |
if (response.statusCode == 401) { | |
await _refreshToken(); | |
return _retry(response.requestOptions); | |
} else if (response.statusCode == 402 || response.statusCode == 403) { | |
await Helpers.clearToken(); | |
AppSnackBar.info(response.data['message']); | |
AppSnackBar.info(response.data['error']); | |
} | |
return response; | |
} catch (error, stackError) { | |
throw AppException( | |
message: error.toString(), stackTrace: stackError.toString()); | |
} | |
} | |
/// handle pop-up message | |
Future _getMessage(String? type) { | |
var selected; | |
switch (type) { | |
case 'no_internet': | |
AppSnackBar.dynamic( | |
seconds: 6, | |
backgroundColor: Colors.black54, | |
title: 'No Internet Connection', | |
icon: Icon(Icons.wifi_tethering_off, color: Colors.white), | |
message: 'Please check your network connection'); | |
break; | |
} | |
return selected; | |
} | |
Future post( | |
String path, | |
dynamic data, | |
) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.post(path, data: data); | |
return _handleResponse(response); | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
return _handleResponse(resError); | |
} | |
return resError; | |
} | |
} else { | |
_getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future<Response> put(String path, dynamic data) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.put(path, data: data); | |
_handleResponse(response); | |
return response; | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
_handleResponse(resError); | |
} | |
return resError; | |
} | |
} else { | |
_getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future delete(String path) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.delete(path); | |
return _handleResponse(response); | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
return _handleResponse(resError); | |
} | |
return resError; | |
} | |
} else { | |
_getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
Future get(String path) async { | |
if (await ConnectionUtils.isNetworkConnected()) { | |
try { | |
final response = await dio.get( | |
path, | |
options: Options( | |
followRedirects: false, | |
validateStatus: (status) { | |
return status! < 500; | |
}, | |
), | |
); | |
return _handleResponse(response); | |
} on BadNetworkApiError { | |
throw BadNetworkException(); | |
} on InternalServerApiError { | |
throw InternalServerException(); | |
} on UnauthorizedApiError catch (e) { | |
throw UnauthenticatedException(errorMessage: e.message); | |
} on ApiErrorMessageError catch (e) { | |
throw ApiErrorMessageException(errorMessage: e.errorMessage); | |
} on DioError catch (e) { | |
var resError; | |
if (e.type == DioErrorType.response) { | |
resError = e.response; | |
return _handleResponse(resError); | |
} | |
return resError; | |
} | |
} else { | |
_getMessage('no_internet'); | |
throw BadNetworkException(); | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment