update

feat(api_service): Update try-catch funtion and handle exception update(loading_animation): Update loading animation using Lottie
2025-06-09 14:29:43 +07:00
parent 477646ab9d
commit 3a8fa3633c
44 changed files with 1659 additions and 1065 deletions
--- a/lib/product/constant/app/app_constants.dart
+++ b/lib/product/constant/app/app_constants.dart
@@ -25,4 +25,5 @@ class ApplicationConstants {
  static const PARTICIPANT_GROUP = "participant";
  static const NO_DATA = "no_data";
  static const LOADING = "loading";
+  static int CALL_API_TIMEOUT = 15;
 }
--- a/lib/product/network/network_manager.dart
+++ b/lib/product/network/network_manager.dart
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:developer';

@@ -12,6 +13,7 @@ class NetworkManager {
  NetworkManager._init();
  static NetworkManager? _instance;
  static NetworkManager? get instance => _instance ??= NetworkManager._init();
+  

  Future<Map<String, String>> getHeaders() async {
    String? token =
@@ -35,15 +37,24 @@ class NetworkManager {
  /// [String] if the request is successful (status code 200), or an empty
  /// string if the request fails
  Future<String> getDataFromServer(String path) async {
-    final url = Uri.https(ApplicationConstants.DOMAIN, path);
-    log("[${DateTime.now().toLocal().toString().split(' ')[1]}] GET url: $url");
-    final headers = await getHeaders();
-    final response = await http.get(url, headers: headers);
-    if (response.statusCode == StatusCodeConstants.OK ||
-        response.statusCode == StatusCodeConstants.CREATED) {
-      return response.body;
-    } else {
-      return "";
+    try {
+      final url = Uri.https(ApplicationConstants.DOMAIN, path);
+      log("[${DateTime.now().toLocal().toString().split(' ')[1]}] GET url: $url");
+      final headers = await getHeaders();
+      final response = await http.get(url, headers: headers).timeout(
+            Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+            onTimeout: () =>
+                throw TimeoutException('Yêu cầu GET hết thời gian'),
+          );
+      if (response.statusCode == StatusCodeConstants.OK ||
+          response.statusCode == StatusCodeConstants.CREATED) {
+        return response.body;
+      } else {
+        throw Exception('Lỗi server: ${response.statusCode}');
+      }
+    } catch (e, stackTrace) {
+      log('Lỗi khi lấy dữ liệu: $e, StackTrace: $stackTrace');
+      throw Exception('Lỗi khi lấy dữ liệu: $e');
    }
  }

@@ -60,6 +71,25 @@ class NetworkManager {
  /// Returns a [Future<String>] containing the server response body.
  Future<String> getDataFromServerWithParams(
      String path, Map<String, dynamic> params) async {
+    try {
+      final url = Uri.https(ApplicationConstants.DOMAIN, path, params);
+      log("[${DateTime.now().toLocal().toString().split(' ')[1]}] GET Params url: $url");
+      final headers = await getHeaders();
+      final response = await http.get(url, headers: headers).timeout(
+            Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+            onTimeout: () =>
+                throw TimeoutException('Yêu cầu GET+PARAM hết thời gian'),
+          );
+      if (response.statusCode == StatusCodeConstants.OK ||
+          response.statusCode == StatusCodeConstants.CREATED) {
+        return response.body;
+      } else {
+        throw Exception('Lỗi server: ${response.statusCode}');
+      }
+    } catch (e, stackTrace) {
+      log('Lỗi khi lấy dữ liệu: $e, StackTrace: $stackTrace');
+      throw Exception('Lỗi khi lấy dữ liệu: $e');
+    }
    final url = Uri.https(ApplicationConstants.DOMAIN, path, params);
    log("[${DateTime.now().toLocal().toString().split(' ')[1]}] GET Params url: $url");
    final headers = await getHeaders();
@@ -77,12 +107,27 @@ class NetworkManager {
  /// [path] is the endpoint for the request, and [body] contains the data
  /// to be sent. Returns the HTTP status code of the response.
  Future<int> createDataInServer(String path, Map<String, dynamic> body) async {
-    final url = Uri.https(ApplicationConstants.DOMAIN, path);
-    log("[${DateTime.now().toLocal().toString().split(' ')[1]}] POST url: $url");
-    final headers = await getHeaders();
-    final response =
-        await http.post(url, headers: headers, body: jsonEncode(body));
-    return response.statusCode;
+    try {
+      final url = Uri.https(ApplicationConstants.DOMAIN, path);
+      log("[${DateTime.now().toLocal().toString().split(' ')[1]}] POST url: $url");
+      final headers = await getHeaders();
+      final response = await http
+          .post(url, headers: headers, body: jsonEncode(body))
+          .timeout(
+            Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+            onTimeout: () =>
+                throw TimeoutException('Yêu cầu POST hết thời gian'),
+          );
+      if (response.statusCode == StatusCodeConstants.OK ||
+          response.statusCode == StatusCodeConstants.CREATED) {
+        return response.statusCode;
+      } else {
+        throw Exception('Lỗi server: ${response.statusCode}');
+      }
+    } catch (e, stackTrace) {
+      log('Lỗi khi lấy dữ liệu: $e, StackTrace: $stackTrace');
+      throw Exception('Lỗi khi lấy dữ liệu: $e');
+    }
  }

  /// Updates existing data on the server using a PUT request.
@@ -90,12 +135,26 @@ class NetworkManager {
  /// [path] is the endpoint for the request, and [body] contains the data
  /// to be updated. Returns the HTTP status code of the response.
  Future<int> updateDataInServer(String path, Map<String, dynamic> body) async {
-    final url = Uri.https(ApplicationConstants.DOMAIN, path);
-    log("[${DateTime.now().toLocal().toString().split(' ')[1]}] PUT url: $url");
-    final headers = await getHeaders();
-    final response =
-        await http.put(url, headers: headers, body: jsonEncode(body));
-    return response.statusCode;
+    try {
+      final url = Uri.https(ApplicationConstants.DOMAIN, path);
+      log("[${DateTime.now().toLocal().toString().split(' ')[1]}] PUT url: $url");
+      final headers = await getHeaders();
+      final response =
+          await http.put(url, headers: headers, body: jsonEncode(body)).timeout(
+                Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+                onTimeout: () =>
+                    throw TimeoutException('Yêu cầu PUT hết thời gian'),
+              );
+      if (response.statusCode == StatusCodeConstants.OK ||
+          response.statusCode == StatusCodeConstants.CREATED) {
+        return response.statusCode;
+      } else {
+        throw Exception('Lỗi server: ${response.statusCode}');
+      }
+    } catch (e, stackTrace) {
+      log('Lỗi khi lấy dữ liệu: $e, StackTrace: $stackTrace');
+      throw Exception('Lỗi khi lấy dữ liệu: $e');
+    }
  }

  /// Deletes data from the server using a DELETE request.
@@ -105,10 +164,24 @@ class NetworkManager {
  /// A status code of 200 indicates success, while other codes indicate
  /// failure or an error.
  Future<int> deleteDataInServer(String path) async {
-    final url = Uri.https(ApplicationConstants.DOMAIN, path);
-    log("[${DateTime.now().toLocal().toString().split(' ')[1]}]   DELETE url: $url");
-    final headers = await getHeaders();
-    final response = await http.delete(url, headers: headers);
-    return response.statusCode;
+    try {
+      final url = Uri.https(ApplicationConstants.DOMAIN, path);
+      log("[${DateTime.now().toLocal().toString().split(' ')[1]}]   DELETE url: $url");
+      final headers = await getHeaders();
+      final response = await http.delete(url, headers: headers).timeout(
+            Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+            onTimeout: () =>
+                throw TimeoutException('Yêu cầu DELETE hết thời gian'),
+          );
+      if (response.statusCode == StatusCodeConstants.OK ||
+          response.statusCode == StatusCodeConstants.CREATED) {
+        return response.statusCode;
+      } else {
+        throw Exception('Lỗi server: ${response.statusCode}');
+      }
+    } catch (e, stackTrace) {
+      log('Lỗi khi lấy dữ liệu: $e, StackTrace: $stackTrace');
+      throw Exception('Lỗi khi lấy dữ liệu: $e');
+    }
  }
 }
--- a/lib/product/services/api_services.dart
+++ b/lib/product/services/api_services.dart
@@ -1,10 +1,21 @@
 // ignore_for_file: use_build_context_synchronously

+import 'dart:async';
 import 'dart:convert';
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
 import 'package:http/http.dart' as http;
+import 'package:sfm_app/product/shared/model/province_model.dart';
+import '../../feature/device_log/device_logs_model.dart';
+import '../../feature/devices/device_model.dart';
+import '../../feature/home/device_alias_model.dart';
+import '../../feature/inter_family/group_detail/group_detail_model.dart';
+import '../../feature/inter_family/groups/groups_model.dart';
+import '../../feature/settings/device_notification_settings/device_notification_settings_model.dart';
+import '../../feature/settings/profile/profile_model.dart';
 import '../constant/app/api_path_constant.dart';
+import '../shared/model/district_model.dart';
+import '../shared/model/ward_model.dart';
 import '../shared/shared_snack_bar.dart';
 import '../constant/enums/app_route_enums.dart';
 import 'language_services.dart';
@@ -41,6 +52,40 @@ class APIServices {
    return headers;
  }

+  Future<T> executeApiCall<T>(
+    Future<dynamic> Function() apiCall, {
+    T Function(dynamic)? parser,
+    String errorMessage = 'Lỗi khi gọi API',
+    T Function(int)? statusCodeHandler, // Thêm handler cho statusCode
+  }) async {
+    try {
+      final response = await apiCall().timeout(
+        Duration(seconds: ApplicationConstants.CALL_API_TIMEOUT),
+        onTimeout: () => throw TimeoutException('Yêu cầu hết thời gian'),
+      );
+
+      if (statusCodeHandler != null && response is int) {
+        return statusCodeHandler(response);
+      }
+
+      if (response is String && response != "") {
+        if (parser != null) {
+          try {
+            return parser(jsonDecode(response));
+          } catch (e) {
+            throw Exception('Lỗi parsing dữ liệu: $e');
+          }
+        }
+        return response as T;
+      } else {
+        throw Exception('Dữ liệu trả về rỗng');
+      }
+    } catch (e, stackTrace) {
+      // log('Lỗi API: $e, StackTrace: $stackTrace');
+      throw Exception('$errorMessage: $e');
+    }
+  }
+
  Future<String> login(String path, Map<String, dynamic> loginRequest) async {
    final url = Uri.https(ApplicationConstants.DOMAIN, path);
    final headers = await getHeaders();
@@ -49,14 +94,11 @@ class APIServices {
    return response.body;
  }

-  Future<int> sendNotificationToken(String token) async{
+  Future<int> sendNotificationToken(String token) async {
    String uid = await getUID();
-    Map<String,dynamic> body = {
-      "user_id": uid,
-      "app_token": token
-    };
-    int statusCode = await NetworkManager.instance!.updateDataInServer(
-        APIPathConstants.NOTIFICATION_TOKEN_PATH, body);
+    Map<String, dynamic> body = {"user_id": uid, "app_token": token};
+    int statusCode = await NetworkManager.instance!
+        .updateDataInServer(APIPathConstants.NOTIFICATION_TOKEN_PATH, body);
    return statusCode;
  }

@@ -122,67 +164,88 @@ class APIServices {
    return language;
  }

-  Future<Bell> getBellNotifications(String offset, String pagesize) async {
-    Bell bell = Bell();
-    final params = {"offset": offset, "page_size": pagesize};
-    final data = await NetworkManager.instance!.getDataFromServerWithParams(
-        APIPathConstants.BELL_NOTIFICATIONS_PATH, params);
-    if (data != "") {
-      bell = Bell.fromJson(jsonDecode(data));
-      return bell;
-    } else {
-      return bell;
-    }
+  Future<Bell> getBellNotifications(String offset, String pageSize) async {
+    final params = {"offset": offset, "page_size": pageSize};
+    return executeApiCall(
+      () => NetworkManager.instance!.getDataFromServerWithParams(
+          APIPathConstants.BELL_NOTIFICATIONS_PATH, params),
+      parser: (json) => Bell.fromJson(json),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.BELL_NOTIFICATIONS_PATH}',
+    );
  }

  Future<int> updateStatusOfNotification(List<String> notificationID) async {
    Map<String, dynamic> body = {
      "event_ids": notificationID,
    };
-    int statusCode = await NetworkManager.instance!.updateDataInServer(
-        APIPathConstants.BELL_UPDATE_READ_NOTIFICATIONS_PATH, body);
-    return statusCode;
+    return executeApiCall(
+      () => NetworkManager.instance!.updateDataInServer(
+          APIPathConstants.BELL_UPDATE_READ_NOTIFICATIONS_PATH, body),
+      statusCodeHandler: (statusCode) => statusCode,
+      errorMessage: 'Lỗi khi PUT /${APIPathConstants.BELL_NOTIFICATIONS_PATH}',
+    );
  }

-  Future<String> getUserDetail() async {
+  Future<User> getUserDetail() async {
    String uid = await getUID();
-    String? response = await NetworkManager.instance!
-        .getDataFromServer('${APIPathConstants.USER_PATH}/$uid');
-    return response;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer('${APIPathConstants.USER_PATH}/$uid'),
+      parser: (json) => User.fromJson(json),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.USER_PATH}',
+    );
  }

  Future<int> updateUserProfile(Map<String, dynamic> body) async {
    String uid = await getUID();
-    int statusCode = await NetworkManager.instance!
-        .updateDataInServer("${APIPathConstants.USER_PROFILE_PATH}/$uid", body);
-    return statusCode;
+    return executeApiCall(
+      () => NetworkManager.instance!.updateDataInServer(
+          "${APIPathConstants.USER_PROFILE_PATH}/$uid", body),
+      statusCodeHandler: (statusCode) => statusCode,
+      errorMessage: 'Lỗi khi PUT /${APIPathConstants.USER_PROFILE_PATH}',
+    );
  }

  Future<int> updateUserPassword(Map<String, dynamic> body) async {
    String uid = await getUID();
-    int statusCode = await NetworkManager.instance!.updateDataInServer(
-        "${APIPathConstants.USER_PATH}/$uid/password", body);
-    return statusCode;
+    // int statusCode = await NetworkManager.instance!.updateDataInServer(
+    //     "${APIPathConstants.USER_PATH}/$uid/password", body);
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            "${APIPathConstants.USER_PATH}/$uid/password", body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi PUT /${APIPathConstants.USER_PATH}');
  }

-  Future<String> getAllSettingsNotificationOfDevices() async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer(APIPathConstants.DEVICE_NOTIFICATION_SETTINGS);
-    return data;
+  Future<List<DeviceNotificationSettings>>
+      getAllSettingsNotificationOfDevices() async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer(APIPathConstants.DEVICE_NOTIFICATION_SETTINGS),
+      parser: (json) =>
+          DeviceNotificationSettings.mapFromJson(json['data']).values.toList(),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.DEVICE_NOTIFICATION_SETTINGS}',
+    );
  }

-  Future<int> updateDeviceNotificationSettings(
-      String thingID, Map<String, int> data) async {
+  Future<int> updateDeviceNotificationSettings(String thingID, Map<String, int> data) async {
    Map<String, dynamic> body = {"thing_id": thingID, "notifi_settings": data};
-    int statusCode = await NetworkManager.instance!.updateDataInServer(
-        APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi PUT /${APIPathConstants.DEVICE_NOTIFICATION_SETTINGS}');
  }

-  Future<String> getDashBoardDevices() async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer(APIPathConstants.DASHBOARD_DEVICES);
-    return data;
+  Future<List<DeviceWithAlias>> getDashBoardDevices() async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer(APIPathConstants.DASHBOARD_DEVICES),
+      parser: (json) => DeviceWithAlias.fromJsonDynamicList(json['items']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.DASHBOARD_DEVICES}',
+    );
  }

  Future<int> setupDeviceNotification(String thingID, String deviceName) async {
@@ -202,68 +265,105 @@ class APIServices {
        "104": 1,
      }
    };
-    int statusCode = await NetworkManager.instance!.updateDataInServer(
-        APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi PUT /${APIPathConstants.DEVICE_NOTIFICATION_SETTINGS}');
  }

-  Future<String> getAllProvinces() async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer(APIPathConstants.PROVINCES_PATH);
-    return data;
+  Future<List<Province>> getAllProvinces() async {
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .getDataFromServer(APIPathConstants.PROVINCES_PATH),
+        parser: (json) => Province.fromJsonDynamicList(json['items']),
+        errorMessage: 'Lỗi khi GET /${APIPathConstants.PROVINCES_PATH}');
+    ;
  }

-  Future<String> getProvincesByName(String name) async {
+  Future<List<Province>> getProvincesByName(String name) async {
    final params = {'name': name};
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.PROVINCES_PATH, params);
-    return data;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.PROVINCES_PATH, params),
+      parser: (json) => Province.fromJsonDynamicList(json['items']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.PROVINCES_PATH}/$name',
+    );
+    ;
  }

-  Future<String> getProvinceByID(String provinceID) async {
-    String data = await NetworkManager.instance!
-        .getDataFromServer("${APIPathConstants.PROVINCES_PATH}/$provinceID");
-    return data;
+  Future<Province> getProvinceByID(String provinceID) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer("${APIPathConstants.PROVINCES_PATH}/$provinceID"),
+      parser: (json) => Province.fromJson(json['data']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.PROVINCES_PATH}/$provinceID}',
+    );
  }

-  Future<String> getAllDistricts(String provinceID) async {
+  Future<List<District>> getAllDistricts(String provinceID) async {
    final params = {"parent": provinceID};
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.DISTRICTS_PATH, params);
-    return data;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.DISTRICTS_PATH, params),
+      parser: (json) => District.fromJsonDynamicList(json['items']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.DISTRICTS_PATH} by parentCode $provinceID',
+    );
  }

-  Future<String> getDistrictsByName(String districtName) async {
+  Future<List<District>> getDistrictsByName(String districtName) async {
    final params = {"name": districtName};
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.DISTRICTS_PATH, params);
-    return data;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.DISTRICTS_PATH, params),
+      parser: (json) => District.fromJsonDynamicList(json['items']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.DISTRICTS_PATH} by name $districtName',
+    );
  }

-  Future<String> getDistrictByID(String districtID) async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer("${APIPathConstants.DISTRICTS_PATH}/$districtID");
-    return data;
+  Future<District> getDistrictByID(String districtID) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer("${APIPathConstants.DISTRICTS_PATH}/$districtID"),
+      parser: (json) => District.fromJson(json['data']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.DISTRICTS_PATH}/$districtID',
+    );
  }

-  Future<String> getAllWards(String districtID) async {
+  Future<List<Ward>> getAllWards(String districtID) async {
    final params = {'parent': districtID};
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.WARDS_PATH, params);
-    return data;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.WARDS_PATH, params),
+      parser: (json) => Ward.fromJsonDynamicList(json['items']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.WARDS_PATH} by parent $districtID',
+    );
  }

-  Future<String> getWarsdByName(String wardName) async {
+  Future<List<Ward>> getWardsByName(String wardName) async {
    final params = {"name": wardName};
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.WARDS_PATH, params);
-    return data;
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.WARDS_PATH, params),
+      parser: (json) => Ward.fromJsonDynamicList(json['items']),
+      errorMessage:
+          'Lỗi khi GET /${APIPathConstants.WARDS_PATH} by name $wardName',
+    );
  }

-  Future<String> getWardByID(String wardID) async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer("${APIPathConstants.WARDS_PATH}/$wardID");
-    return data;
+  Future<Ward> getWardByID(String wardID) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer("${APIPathConstants.WARDS_PATH}/$wardID"),
+      parser: (json) => Ward.fromJson(json['data']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.WARDS_PATH}/$wardID',
+    );
  }

  Future<int> confirmFakeFireByUser(String thingID) async {
@@ -271,131 +371,187 @@ class APIServices {
      "state": 3,
      "note": "Người dùng xác nhận cháy giả!"
    };
-    int statusCode = await NetworkManager.instance!
-        .updateDataInServer("${APIPathConstants.DEVICE_PATH}/$thingID", body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            "${APIPathConstants.DEVICE_PATH}/$thingID", body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi PUT /${APIPathConstants.DEVICE_PATH}/$thingID');
  }

-  Future<String> getOwnerDevices() async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServer(APIPathConstants.DEVICE_PATH);
-    return data;
+  Future<List<Device>> getOwnerDevices() async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer(APIPathConstants.DEVICE_PATH),
+      parser: (json) => Device.fromJsonDynamicList(json['items']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.DEVICE_PATH}',
+    );
  }

-  Future<String> getOwnerDeviceByState(Map<String, dynamic> params) async {
-    String? data = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.DEVICE_PATH, params);
-    return data;
+  Future<List<Device>> getOwnerDeviceByState(
+      Map<String, dynamic> params) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServerWithParams(APIPathConstants.DEVICE_PATH, params),
+      parser: (json) => Device.fromJsonDynamicList(json['items']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.DEVICE_PATH}',
+    );
  }

  Future<int> createDeviceByAdmin(Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.DEVICE_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.DEVICE_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi POST /${APIPathConstants.DEVICE_PATH}');
  }

  Future<int> registerDevice(Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.DEVICE_REGISTER_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.DEVICE_REGISTER_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi POST /${APIPathConstants.DEVICE_REGISTER_PATH}');
  }

  Future<int> deleteDeviceByAdmin(String thingID) async {
-    int statusCode = await NetworkManager.instance!
-        .deleteDataInServer("${APIPathConstants.DEVICE_PATH}/$thingID");
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .deleteDataInServer("${APIPathConstants.DEVICE_PATH}/$thingID"),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi DELETE /${APIPathConstants.DEVICE_PATH}/$thingID');
  }

  Future<int> unregisterDevice(Map<String, dynamic> body) async {
-    int statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.DEVICE_UNREGISTER_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.DEVICE_UNREGISTER_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi DELETE /${APIPathConstants.DEVICE_UNREGISTER_PATH} by USER');
  }

-  Future<String> getDeviceInfomation(String thingID) async {
-    String? response = await NetworkManager.instance!
-        .getDataFromServer("${APIPathConstants.DEVICE_PATH}/$thingID");
-    return response;
+  Future<Device> getDeviceInformation(String thingID) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer("${APIPathConstants.DEVICE_PATH}/$thingID"),
+      parser: (json) => Device.fromJson(json),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.DEVICE_PATH}/$thingID',
+    );
  }

-  Future<String> getAllGroups() async {
-    String? body = await NetworkManager.instance!
-        .getDataFromServer(APIPathConstants.ALL_GROUPS_PATH);
-    return body;
+  Future<List<Group>> getAllGroups() async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer(APIPathConstants.ALL_GROUPS_PATH),
+      parser: (json) => Group.fromJsonDynamicList(json['items']),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.USER_PATH}',
+    );
  }

  Future<int> createGroup(Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.GROUPS_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.GROUPS_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi POST /${APIPathConstants.GROUPS_PATH}');
  }

  Future<int> updateGroup(Map<String, dynamic> body, String groupID) async {
-    int? statusCode = await NetworkManager.instance!
-        .updateDataInServer("${APIPathConstants.GROUPS_PATH}/$groupID", body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            "${APIPathConstants.GROUPS_PATH}/$groupID", body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi PUT /${APIPathConstants.GROUPS_PATH}/$groupID');
  }

  Future<int> joinGroup(String groupID, Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.JOIN_GROUP_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.JOIN_GROUP_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi POST /${APIPathConstants.JOIN_GROUP_PATH}');
  }

  Future<int> deleteGroup(String groupID) async {
-    int? statusCode = await NetworkManager.instance!
-        .deleteDataInServer("${APIPathConstants.GROUPS_PATH}/$groupID");
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .deleteDataInServer("${APIPathConstants.GROUPS_PATH}/$groupID"),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi DELETE /${APIPathConstants.GROUPS_PATH}/$groupID');
  }

-  Future<String> getGroupDetail(String groupID) async {
-    String? body = await NetworkManager.instance!
-        .getDataFromServer("${APIPathConstants.GROUPS_PATH}/$groupID");
-    return body;
+  Future<GroupDetail> getGroupDetail(String groupID) async {
+    return executeApiCall(
+      () => NetworkManager.instance!
+          .getDataFromServer("${APIPathConstants.GROUPS_PATH}/$groupID"),
+      parser: (json) => GroupDetail.fromJson(json),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.GROUPS_PATH}/$groupID',
+    );
  }

  Future<int> approveGroup(Map<String, dynamic> body) async {
-    int statusCode = await NetworkManager.instance!
-        .createDataInServer(APIPathConstants.APPROVE_GROUP_PATH, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!
+            .createDataInServer(APIPathConstants.APPROVE_GROUP_PATH, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi POST /${APIPathConstants.APPROVE_GROUP_PATH}');
  }

  Future<int> deleteUserInGroup(String groupID, String userID) async {
-    int? statusCode = await NetworkManager.instance!.deleteDataInServer(
-        "${APIPathConstants.GROUPS_PATH}/$groupID/users/$userID");
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.deleteDataInServer(
+            "${APIPathConstants.GROUPS_PATH}/$groupID/users/$userID"),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi DELETE /${APIPathConstants.GROUPS_PATH}/$groupID/users/$userID');
  }

  Future<int> deleteDeviceInGroup(String groupID, String thingID) async {
-    int? statusCode = await NetworkManager.instance!.deleteDataInServer(
-        "${APIPathConstants.GROUPS_PATH}/$groupID/devices/$thingID");
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.deleteDataInServer(
+            "${APIPathConstants.GROUPS_PATH}/$groupID/devices/$thingID"),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi DELETE /${APIPathConstants.GROUPS_PATH}/$groupID/devices/$thingID');
  }

  Future<int> updateDeviceAlias(Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!.updateDataInServer(
-        APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            APIPathConstants.DEVICE_NOTIFICATION_SETTINGS, body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi PUT /${APIPathConstants.DEVICE_NOTIFICATION_SETTINGS}');
  }

  Future<int> addDeviceToGroup(
      String groupID, Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!.createDataInServer(
-        "${APIPathConstants.GROUPS_PATH}/$groupID/things", body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.createDataInServer(
+            "${APIPathConstants.GROUPS_PATH}/$groupID/things", body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage:
+            'Lỗi khi PUT /${APIPathConstants.GROUPS_PATH}/$groupID/things');
  }

  Future<int> updateOwnerDevice(
      String thingID, Map<String, dynamic> body) async {
-    int? statusCode = await NetworkManager.instance!
-        .updateDataInServer("${APIPathConstants.DEVICE_PATH}/$thingID", body);
-    return statusCode;
+    return executeApiCall(
+        () => NetworkManager.instance!.updateDataInServer(
+            "${APIPathConstants.DEVICE_PATH}/$thingID", body),
+        statusCodeHandler: (statusCode) => statusCode,
+        errorMessage: 'Lỗi khi PUT /${APIPathConstants.DEVICE_PATH}/$thingID');
  }

-  Future<String> getLogsOfDevice(
+  Future<DeviceLog> getLogsOfDevice(
      String thingID, Map<String, dynamic> params) async {
-    String? body = await NetworkManager.instance!
-        .getDataFromServerWithParams(APIPathConstants.DEVICE_LOGS_PATH, params);
-    return body;
+    return executeApiCall(
+      () => NetworkManager.instance!.getDataFromServerWithParams(
+          APIPathConstants.DEVICE_LOGS_PATH, params),
+      parser: (json) => DeviceLog.fromJson(json),
+      errorMessage: 'Lỗi khi GET /${APIPathConstants.DEVICE_LOGS_PATH}',
+    );
  }
 }
--- a/lib/product/shared/shared_component_loading_animation.dart
+++ b/lib/product/shared/shared_component_loading_animation.dart
@@ -0,0 +1,23 @@
+import 'package:flutter/material.dart';
+import 'package:lottie/lottie.dart';
+
+class SharedComponentLoadingAnimation extends StatefulWidget {
+  const SharedComponentLoadingAnimation({super.key});
+
+  @override
+  State<SharedComponentLoadingAnimation> createState() => _SharedComponentLoadingAnimationState();
+}
+
+class _SharedComponentLoadingAnimationState extends State<SharedComponentLoadingAnimation> {
+  @override
+  Widget build(BuildContext context) {
+    return Center(
+      child: LottieBuilder.asset(
+        'assets/animations/component_loading.json',
+        width: 80,
+        height: 80,
+        fit: BoxFit.fill,
+      ),
+    );
+  }
+}
--- a/lib/product/shared/shared_loading_animation.dart
+++ b/lib/product/shared/shared_loading_animation.dart
@@ -0,0 +1,23 @@
+import 'package:flutter/material.dart';
+import 'package:lottie/lottie.dart';
+
+class SharedLoadingAnimation extends StatefulWidget {
+  const SharedLoadingAnimation({super.key});
+
+  @override
+  State<SharedLoadingAnimation> createState() => _SharedLoadingAnimationState();
+}
+
+class _SharedLoadingAnimationState extends State<SharedLoadingAnimation> {
+  @override
+  Widget build(BuildContext context) {
+    return Center(
+      child: LottieBuilder.asset(
+        'assets/animations/loading.json',
+        width: 100,
+        height: 100,
+        fit: BoxFit.fill,
+      ),
+    );
+  }
+}
--- a/lib/product/shared/shared_pie_chart.dart
+++ b/lib/product/shared/shared_pie_chart.dart
@@ -182,23 +182,23 @@ class _SharedPieChartState extends State<SharedPieChart> {
        switch (originalIndex) {
          case 0: // OFFLINE_STATE
            log("Touched Index device state = -1");
-            widget.devicesManagerBloc.getDeviceByState(-1);
+            widget.devicesManagerBloc.getDeviceByState(context,-1);
            break;
          case 1: // NORMAL_STATE
            log("Touched Index Get device state = 0");
-            widget.devicesManagerBloc.getDeviceByState(0);
+            widget.devicesManagerBloc.getDeviceByState(context,0);
            break;
          case 2: // WARNING_STATE
            log("Touched Index Get device state = 1");
-            widget.devicesManagerBloc.getDeviceByState(1);
+            widget.devicesManagerBloc.getDeviceByState(context,1);
            break;
          case 3: // INPROGRESS_STATE
            log("Touched Index Get device state = 2");
-            widget.devicesManagerBloc.getDeviceByState(2);
+            widget.devicesManagerBloc.getDeviceByState(context,2);
            break;
          case 4: // ERROR_STATE
            log("Touched Index Get device state = 3");
-            widget.devicesManagerBloc.getDeviceByState(3);
+            widget.devicesManagerBloc.getDeviceByState(context,3);
            break;
        }
      }
--- a/lib/product/utils/device_utils.dart
+++ b/lib/product/utils/device_utils.dart
@@ -93,30 +93,34 @@ class DeviceUtils {
    return map;
  }

+
  Future<String> getFullDeviceLocation(
-      BuildContext context, String areaPath) async {
-    if (areaPath != "") {
+      BuildContext context, String areaPath, String? deviceName) async {
+    if (areaPath.isNotEmpty) {
      List<String> parts = areaPath.split('_');

+      if (parts.length < 3 || parts[0].isEmpty || parts[1].isEmpty || parts[2].isEmpty) {
+        if (deviceName != null && deviceName.isNotEmpty) {
+          return deviceName;
+        } else {
+          return appLocalization(context).no_data_message;
+        }
+      }
+
      String provinceID = parts[0];
      String districtID = parts[1];
      String wardID = parts[2];

-      String provinceBody = await apiServices.getProvinceByID(provinceID);
-      final provinceItem = jsonDecode(provinceBody);
-      Province province = Province.fromJson(provinceItem['data']);
-      String districtBody = await apiServices.getDistrictByID(districtID);
-      final districtItem = jsonDecode(districtBody);
-      District district = District.fromJson(districtItem['data']);
-      String wardBody = await apiServices.getWardByID(wardID);
-      final wardItem = jsonDecode(wardBody);
-      Ward ward = Ward.fromJson(wardItem['data']);
-
+      Province province = await apiServices.getProvinceByID(provinceID);
+      District district = await apiServices.getDistrictByID(districtID);
+      Ward ward = await apiServices.getWardByID(wardID);
      return "${ward.fullName}, ${district.fullName}, ${province.fullName}";
    }
+
    return appLocalization(context).no_data_message;
  }

+
  String checkStateDevice(BuildContext context, int state) {
    String message = appLocalization(context).no_data_message;
    if (state == 1) {
@@ -157,11 +161,11 @@ class DeviceUtils {
    } else if (state == 0) {
      return const Color(0xFF9EF16D);
    } else if (state == 2) {
-      return const Color(0xFFF5EF44);;
+      return const Color(0xFFF5EF44);
    } else if (state == -1) {
-      return const Color(0xFFBBBAC2);;
+      return const Color(0xFFBBBAC2);
    } else {
-      return const Color(0xFFF5EF44);;
+      return const Color(0xFFF5EF44);
    }
  }