service 2-5-26-1

2026-05-02 15:12:46 +03:00
parent c3f29f30c1
commit 255724418c
25 changed files with 1063 additions and 530 deletions
--- a/lib/controller/functions/crud.dart
+++ b/lib/controller/functions/crud.dart
@@ -1,82 +1,244 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:io';

+import 'package:get/get.dart';
 import 'package:http/http.dart' as http;
-import 'package:jwt_decoder/jwt_decoder.dart';
-import 'package:secure_string_operations/secure_string_operations.dart';
-import 'package:service/constant/char_map.dart';
+import 'package:service/constant/box_name.dart';
+import 'package:service/constant/links.dart';
+import 'package:service/controller/functions/encrypt_decrypt.dart';
+import 'package:service/env/env.dart';
+import 'package:service/main.dart';
+import 'package:service/print.dart';

 import '../../constant/api_key.dart';
-import '../../constant/box_name.dart';
-import '../../constant/info.dart';
-import '../../constant/links.dart';
-import '../../main.dart';
-import '../../print.dart';
-import 'encrypt_decrypt.dart';
-import 'initilize.dart';

 class CRUD {
-  var dev;
-  getJWT(String pass, email) async {
-    var dev = Platform.isAndroid ? 'android' : 'ios';
-    var payload = {
-      'password': box.read(BoxName.password) ?? pass,
-      'email': box.read(BoxName.email) ?? email,
-      'aud': '${AK.allowed}$dev',
-    };
-    var response0 = await http.post(
-      Uri.parse(AppLink.jwtService),
-      body: payload,
-    );
+  static bool _isRefreshingJWT = false;
+  static String _lastErrorSignature = '';
+  static DateTime _lastErrorTimestamp = DateTime(2000);
+  static const Duration _errorLogDebounceDuration = Duration(minutes: 1);

-    if (response0.statusCode == 200) {
-      final decodedResponse1 = jsonDecode(response0.body);
-
-      final jwt = decodedResponse1['jwt'];
-      Log.print('jwt: ${jwt}');
-      box.write(BoxName.jwt, X.c(X.c(X.c(jwt, cn), cC), cs));
+  // ── JWT Validity Check (No external libs) ──────────────────────
+  static bool _isJwtValid(String? token) {
+    if (token == null || token.isEmpty) return false;
+    try {
+      final parts = token.split('.');
+      if (parts.length != 3) return false;
+      String payload = parts[1];
+      switch (payload.length % 4) {
+        case 2:
+          payload += '==';
+          break;
+        case 3:
+          payload += '=';
+          break;
+      }
+      final decoded = jsonDecode(utf8.decode(base64Url.decode(payload)));
+      final exp = decoded['exp'];
+      if (exp == null) return false;
+      // 30 seconds buffer
+      return DateTime.now().millisecondsSinceEpoch < (exp * 1000 - 30000);
+    } catch (_) {
+      return false;
    }
  }

+  static Future<void> addError(
+      String error, String details, String where) async {
+    try {
+      final currentErrorSignature = '$where-$error';
+      final now = DateTime.now();
+
+      if (currentErrorSignature == _lastErrorSignature &&
+          now.difference(_lastErrorTimestamp) < _errorLogDebounceDuration) {
+        return;
+      }
+
+      _lastErrorSignature = currentErrorSignature;
+      _lastErrorTimestamp = now;
+
+      final userId =
+          box.read(BoxName.driverID) ?? box.read(BoxName.passengerID);
+      final userType = 'Service';
+      final phone = box.read(BoxName.phone) ?? box.read(BoxName.phoneDriver);
+
+      CRUD().post(
+        link: AppLink.addError,
+        payload: {
+          'error': error.toString(),
+          'userId': userId.toString(),
+          'userType': userType,
+          'phone': phone.toString(),
+          'device': where,
+          'details': details,
+        },
+      );
+    } catch (e) {}
+  }
+
+  String _getFpHeader() {
+    return box.read(BoxName.fingerPrint)?.toString() ?? '';
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // _makeRequest — Central Request Handler
+  // ───────────────────────────────────────────────────────────────
+  Future<dynamic> _makeRequest({
+    required String link,
+    Map<String, dynamic>? payload,
+    required Map<String, String> headers,
+  }) async {
+    const totalTimeout = Duration(seconds: 60);
+
+    Future<http.Response> doPost() {
+      final url = Uri.parse(link);
+      return http
+          .post(url, body: payload, headers: headers)
+          .timeout(totalTimeout);
+    }
+
+    http.Response? response;
+    int attempts = 0;
+    final requestId =
+        DateTime.now().millisecondsSinceEpoch.toString().substring(7);
+
+    Log.print('🚀 [REQ-$requestId] $link');
+    Log.print('🔑 [FP-$requestId] ${headers['X-Device-FP']}');
+    if (payload != null) Log.print('📦 [PAYLOAD-$requestId] $payload');
+
+
+    while (attempts < 3) {
+      try {
+        attempts++;
+        response = await doPost();
+        break;
+      } on SocketException catch (_) {
+        Log.print('⚠️ SocketException attempt $attempts — $link');
+        if (attempts >= 3) return 'no_internet';
+        await Future.delayed(const Duration(seconds: 1));
+      } on TimeoutException catch (_) {
+        Log.print('⚠️ TimeoutException attempt $attempts — $link');
+        if (attempts >= 3) return 'failure';
+      } catch (e) {
+        if (e.toString().contains('errno = 9') && attempts < 3) {
+          await Future.delayed(const Duration(milliseconds: 500));
+          continue;
+        }
+        addError(
+            'HTTP Exception: $e', 'Try: $attempts', 'CRUD._makeRequest $link');
+        return 'failure';
+      }
+    }
+
+    if (response == null) return 'failure';
+
+    final sc = response.statusCode;
+    final body = response.body;
+
+    Log.print('📥 [RES-$requestId] [$sc] $link');
+    Log.print('📄 [BODY-$requestId] $body');
+
+    if (sc >= 200 && sc < 300) {
+      try {
+        return jsonDecode(body);
+      } catch (e, st) {
+        addError(
+            'JSON Decode Error', 'Body: $body\n$st', 'CRUD._makeRequest $link');
+        return 'failure';
+      }
+    }
+
+    if (sc == 401) {
+      if (!_isRefreshingJWT && !link.contains('errorApp.php')) {
+        _isRefreshingJWT = true;
+        try {
+          await getJWT();
+        } finally {
+          _isRefreshingJWT = false;
+        }
+      }
+      return 'token_expired';
+    }
+
+    if (sc >= 500) {
+      addError('Server 5xx', 'SC: $sc\nBody: $body', 'CRUD._makeRequest $link');
+      return 'failure';
+    }
+
+    return 'failure';
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // post — standard POST
+  // ═══════════════════════════════════════════════════════════════
+  Future<dynamic> post({
+    required String link,
+    Map<String, dynamic>? payload,
+  }) async {
+    String token = r(box.read(BoxName.jwt) ?? '').toString().split(Env.addd)[0];
+
+    if (!_isJwtValid(token) &&
+        !_isRefreshingJWT &&
+        !link.contains('login.php')) {
+      _isRefreshingJWT = true;
+      try {
+        await getJWT();
+        token = r(box.read(BoxName.jwt) ?? '').toString().split(Env.addd)[0];
+      } finally {
+        _isRefreshingJWT = false;
+      }
+    }
+
+    final headers = {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Authorization': 'Bearer $token',
+      'X-Device-FP': _getFpHeader(),
+    };
+
+    return await _makeRequest(link: link, payload: payload, headers: headers);
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // get — standard GET (uses POST method in this architecture)
+  // ═══════════════════════════════════════════════════════════════
  Future<dynamic> get({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
-    var url = Uri.parse(
-      link,
-    );
-    bool isTokenExpired = JwtDecoder.isExpired(X
-        .r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs)
-        .toString()
-        .split(AppInformation.addd)[0]);
-
-    if (isTokenExpired) {
-      await getJWT(box.read(BoxName.password), box.read(BoxName.email));
-    }
-    var response = await http.post(
-      url,
-      body: payload,
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        'Authorization':
-            'Bearer ${X.r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs).toString().split(AppInformation.addd)[0]}'
-      },
-    );
-    Log.print('esponse.body: ${response.body}');
-    Log.print('esponse.req: ${response.request}');
-    Log.print('payload: ${payload}');
-
-    var jsonData = jsonDecode(response.body);
-
-    Log.print('jsonData: ${jsonData}');
-    if (jsonData['status'] == 'success') {
-      return response.body;
-    }
-
-    return jsonData['status'];
+    return await post(link: link, payload: payload);
  }

-  // }
+  // ═══════════════════════════════════════════════════════════════
+  // getJWT — V1 Login Flow
+  // ═══════════════════════════════════════════════════════════════
+  Future<void> getJWT() async {
+    var payload = {
+      'fingerprint': _getFpHeader(),
+      'password': box.read(BoxName.password) ?? '',
+      'aud': 'service',
+    };
+
+    final headers = {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    };
+
+    final response = await _makeRequest(
+        link: AppLink.login, payload: payload, headers: headers);
+
+    if (response != 'failure' &&
+        response is Map &&
+        response['status'] == 'success') {
+      final jwt = response['message']['jwt'];
+      Log.print('jwt: $jwt');
+      box.write(BoxName.jwt, c(jwt));
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // Service Specific Methods (Preserved)
+  // ─────────────────────────────────────────────────────────────
+
  Future<dynamic> arabicTextExtractByVisionAndAI({
    required String imagePath,
    required String driverID,
@@ -99,24 +261,24 @@ class CRUD {

    if (response.statusCode == 200) {
      return await response.stream.bytesToString();
-    } else {}
+    }
+    return 'failure';
  }

  Future<dynamic> getAgoraToken({
    required String channelName,
    required String uid,
  }) async {
-    var uid = box.read(BoxName.phone) ?? box.read(BoxName.phoneDriver);
-    var res = await http.get(Uri.parse(
-            // 'https://repulsive-pig-rugby-shirt.cyclic.app/token?channelName=$channelName'),
+    var res = await http.get(
+        Uri.parse(
            'https://orca-app-b2i85.ondigitalocean.app/token?channelName=$channelName'),
-        // headers: {'Authorization': 'Bearer ${AK.agoraAppCertificate}'});
        headers: {'Authorization': 'Bearer '});

    if (res.statusCode == 200) {
      var response = jsonDecode(res.body);
      return response['token'];
-    } else {}
+    }
+    return 'failure';
  }

  Future<dynamic> getLlama({
@@ -124,18 +286,14 @@ class CRUD {
    required String payload,
    required String prompt,
  }) async {
-    var url = Uri.parse(
-      link,
-    );
+    var url = Uri.parse(link);
    var headers = {
      'Content-Type': 'application/json',
      'Authorization':
          'Bearer LL-X5lJ0Px9CzKK0HTuVZ3u2u4v3tGWkImLTG7okGRk4t25zrsLqJ0qNoUzZ2x4ciPy'
-      // 'Authorization': 'Bearer ${Env.llamaKey}'
    };
    var data = json.encode({
      "model": "Llama-3-70b-Inst-FW",
-      // "model": "llama-13b-chat",
      "messages": [
        {
          "role": "user",
@@ -145,11 +303,7 @@ class CRUD {
      ],
      "temperature": 0.9
    });
-    var response = await http.post(
-      url,
-      body: data,
-      headers: headers,
-    );
+    var response = await http.post(url, body: data, headers: headers);

    if (response.statusCode == 200) {
      return response.body;
@@ -157,54 +311,7 @@ class CRUD {
    return response.statusCode;
  }

-  Future<dynamic> post({
-    required String link,
-    Map<String, dynamic>? payload,
-  }) async {
-    // String? basicAuthCredentials =
-    //     await storage.read(key: BoxName.basicAuthCredentials);
-    var url = Uri.parse(
-      link,
-    );
-    bool isTokenExpired = JwtDecoder.isExpired(X
-        .r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs)
-        .toString()
-        .split(AppInformation.addd)[0]);
-
-    if (isTokenExpired) {
-      await getJWT(box.read(BoxName.password), box.read(BoxName.email));
-    }
-    var response = await http.post(
-      url,
-      body: payload,
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        'Authorization':
-            'Bearer ${X.r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs).toString().split(AppInformation.addd)[0]}'
-      },
-    );
-    Log.print('req: ${response.request}');
-    Log.print('res: ${response.body}');
-    var jsonData = jsonDecode(response.body);
-
-    if (response.statusCode == 200) {
-      if (jsonData['status'] == 'success') {
-        return response.body;
-      } else {
-        String errorMessage = jsonData['message'];
-        // Get.snackbar('Error'.tr, errorMessage.tr,
-        //     backgroundColor: AppColor.redColor);
-        return (jsonData['status']);
-      }
-    } else {
-      return response.statusCode;
-    }
-  }
-
-  sendEmail(
-    String link,
-    Map<String, String>? payload,
-  ) async {
+  sendEmail(String link, Map<String, String>? payload) async {
    var headers = {
      "Content-Type": "application/x-www-form-urlencoded",
      'Authorization':
@@ -215,45 +322,6 @@ class CRUD {
    request.headers.addAll(headers);

    http.StreamedResponse response = await request.send();
-    if (response.statusCode == 200) {
-    } else {}
+    if (response.statusCode == 200) {}
  }
-
-  Future<dynamic> update({
-    required String endpoint,
-    required Map<String, dynamic> data,
-    required String id,
-  }) async {
-    // String? basicAuthCredentials =
-    //     await storage.read(key: BoxName.basicAuthCredentials);
-    var url = Uri.parse('$endpoint/$id');
-    var response = await http.put(
-      url,
-      body: json.encode(data),
-      headers: {
-        'Authorization':
-            'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
-      },
-    );
-    return json.decode(response.body);
-  }
-
-  Future<dynamic> delete({
-    required String endpoint,
-    required String id,
-  }) async {
-    // String? basicAuthCredentials =
-    //     await storage.read(key: BoxName.basicAuthCredentials);
-    var url = Uri.parse('$endpoint/$id');
-    var response = await http.delete(
-      url,
-      headers: {
-        'Authorization':
-            'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
-      },
-    );
-    return json.decode(response.body);
-  }
-
-  extractTextFromLines(json) {}
 }
--- a/lib/controller/functions/device_helper.dart
+++ b/lib/controller/functions/device_helper.dart
@@ -0,0 +1,49 @@
+import 'dart:io';
+import 'package:device_info_plus/device_info_plus.dart';
+import 'package:flutter/foundation.dart';
+import 'package:service/constant/box_name.dart';
+import 'package:service/controller/functions/encrypt_decrypt.dart';
+import '../../main.dart';
+import '../../print.dart';
+
+class DeviceHelper {
+  static Future<String> getDeviceFingerprint() async {
+    await EncryptionHelper.initialize();
+    final DeviceInfoPlugin deviceInfoPlugin = DeviceInfoPlugin();
+    var deviceData;
+
+    try {
+      if (Platform.isAndroid) {
+        AndroidDeviceInfo androidInfo = await deviceInfoPlugin.androidInfo;
+        deviceData = androidInfo.toMap();
+      } else if (Platform.isIOS) {
+        IosDeviceInfo iosInfo = await deviceInfoPlugin.iosInfo;
+        deviceData = iosInfo.toMap();
+      } else {
+        throw UnsupportedError('Unsupported platform');
+      }
+
+      final String deviceId = Platform.isAndroid
+          ? deviceData['id'] ??
+              deviceData['androidId'] ??
+              deviceData['fingerprint'] ??
+              'unknown'
+          : deviceData['identifierForVendor'] ?? 'unknown';
+
+      final String deviceModel = deviceData['model'] ?? 'unknown';
+
+      Log.print('DeviceId: $deviceId');
+      Log.print('DeviceModel: $deviceModel');
+
+      final String fingerprint =
+          EncryptionHelper.instance.encryptData('${deviceId}_$deviceModel');
+
+      Log.print('Generated Fingerprint: $fingerprint');
+      box.write(BoxName.fingerPrint, fingerprint);
+      return (fingerprint);
+    } catch (e) {
+      Log.print('Error generating device fingerprint: $e');
+      return '';
+    }
+  }
+}
--- a/lib/controller/functions/encrypt_decrypt.dart
+++ b/lib/controller/functions/encrypt_decrypt.dart
@@ -2,8 +2,10 @@ import 'package:encrypt/encrypt.dart' as encrypt;
 import 'package:flutter/foundation.dart';
 import 'package:service/env/env.dart';

-import '../../constant/box_name.dart';
-import '../../main.dart';
+import 'package:secure_string_operations/secure_string_operations.dart';
+import 'package:service/constant/char_map.dart';
+import 'package:service/print.dart';
+

 class EncryptionHelper {
  static EncryptionHelper? _instance;
@@ -28,29 +30,35 @@ class EncryptionHelper {
    }
    debugPrint("Initializing EncryptionHelper...");
    // Read stored keys
-    String? keyOfApp = Env.keyOfApp;
-    // Log.print('keyOfApp: ${keyOfApp}');
-    String? initializationVector = Env.initializationVector;
-    // Log.print('initializationVector: ${initializationVector}');
+    String keyOfApp = r(Env.keyOfApp).toString().split(Env.addd)[0];
+    String initializationVector = r(Env.initializationVector).toString().split(Env.addd)[0];
+
+    Log.print('Key Length: ${keyOfApp.length}');
+    Log.print('IV Length: ${initializationVector.length}');
+
    // Set the global instance
    _instance = EncryptionHelper._(
-      encrypt.Key.fromUtf8(keyOfApp!),
-      encrypt.IV.fromUtf8(initializationVector!),
+      encrypt.Key.fromUtf8(keyOfApp),
+      encrypt.IV.fromUtf8(initializationVector),
    );
    debugPrint("EncryptionHelper initialized successfully.");
  }

+
  /// Encrypts a string
  String encryptData(String plainText) {
+    Log.print('Encrypting: $plainText');
    try {
+
      final encrypter =
          encrypt.Encrypter(encrypt.AES(key, mode: encrypt.AESMode.cbc));
      final encrypted = encrypter.encrypt(plainText, iv: iv);
      return encrypted.base64;
    } catch (e) {
-      debugPrint('Encryption Error: $e');
+      Log.print('Encryption Error: $e');
      return '';
    }
+
  }

  /// Decrypts a string
@@ -66,3 +74,14 @@ class EncryptionHelper {
    }
  }
 }
+
+r(String string) {
+  var res = X.r(X.r(X.r(string, cn), cC), cs).toString();
+  // Log.print('r($string) => $res');
+  return res;
+}
+
+
+c(String string) {
+  return X.c(X.c(X.c(string, cn), cC), cs).toString();
+}
--- a/lib/controller/functions/image.dart
+++ b/lib/controller/functions/image.dart
@@ -14,6 +14,9 @@ import '../../constant/api_key.dart';
 import '../../constant/box_name.dart';
 import '../../constant/colors.dart';
 import '../../main.dart';
+import 'package:service/controller/functions/encrypt_decrypt.dart';
+import 'package:service/env/env.dart';
+

 class ImageController extends GetxController {
  File? myImage;
@@ -199,12 +202,13 @@ class ImageController extends GetxController {
      length,
      filename: basename(file.path),
    );
+    String token = r(box.read(BoxName.jwt) ?? '').toString().split(Env.addd)[0];
    request.headers.addAll({
      'Cache-Control': 'no-cache, no-store, must-revalidate',
      'Pragma': 'no-cache',
      'Expires': '0',
-      'Authorization':
-          'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials.toString()))}',
+      'Authorization': 'Bearer $token',
+      'X-Device-FP': box.read(BoxName.fingerPrint)?.toString() ?? '',
    });
    // Set the file name to the driverID
    request.files.add(
@@ -292,9 +296,10 @@ class ImageController extends GetxController {
      length,
      filename: basename(file.path),
    );
+    String token = r(box.read(BoxName.jwt) ?? '').toString().split(Env.addd)[0];
    request.headers.addAll({
-      'Authorization':
-          'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials.toString()))}',
+      'Authorization': 'Bearer $token',
+      'X-Device-FP': box.read(BoxName.fingerPrint)?.toString() ?? '',
    });
    // Set the file name to the driverID
    request.files.add(
--- a/lib/controller/functions/initilize.dart
+++ b/lib/controller/functions/initilize.dart
@@ -34,7 +34,7 @@ class AppInitializer {
      var res =
          await CRUD().get(link: Env.getapiKey, payload: {"keyName": key1});
      if (res != 'failure') {
-        var d = jsonDecode(res)['message'];
+        var d = res['message'];
        await storage.write(key: key1, value: d[key1].toString());
        await Future.delayed(Duration.zero);
      } else {}