first commit

siro_rider/lib/controller/auth/apple_signin_controller.dart

@@ -0,0 +1,37 @@
+import 'package:firebase_auth/firebase_auth.dart';
+import 'package:get/get.dart';
+import 'package:sign_in_with_apple/sign_in_with_apple.dart';
+
+class AuthController extends GetxController {
+  final FirebaseAuth _auth = FirebaseAuth.instance;
+
+  Future<User?> signInWithApple() async {
+    try {
+      final appleCredential = await SignInWithApple.getAppleIDCredential(
+        scopes: [
+          AppleIDAuthorizationScopes.email,
+          AppleIDAuthorizationScopes.fullName,
+        ],
+      );
+
+      final oAuthProvider = OAuthProvider('apple.com');
+      final credential = oAuthProvider.credential(
+        idToken: appleCredential.identityToken,
+        accessToken: appleCredential.authorizationCode,
+      );
+
+      UserCredential userCredential =
+          await _auth.signInWithCredential(credential);
+
+      return userCredential.user;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  Future<void> signOut() async {
+    try {
+      await _auth.signOut();
+    } catch (error) {}
+  }
+}

siro_rider/lib/controller/auth/certificate.dart

@@ -0,0 +1,41 @@
+import 'package:siro_rider/print.dart';
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+import 'package:crypto/crypto.dart';
+
+Future<bool> verifyCertificateManually(
+    String host, int port, String expectedPin) async {
+  try {
+    final socket = await SecureSocket.connect(host, port,
+        timeout: const Duration(seconds: 5));
+
+    final certificate = socket.peerCertificate;
+    if (certificate == null) {
+      Log.print("❌ لا يوجد شهادة.");
+      return false;
+    }
+
+    final der = certificate.der;
+    final actualPin = base64.encode(sha256.convert(der).bytes);
+
+    Log.print("📛 HOST: $host");
+    Log.print("📜 Subject: ${certificate.subject}");
+    Log.print("📜 Issuer: ${certificate.issuer}");
+    Log.print("📅 Valid From: ${certificate.startValidity}");
+    Log.print("📅 Valid To: ${certificate.endValidity}");
+    Log.print(
+        "🔐 Server Pin: $actualPin → ${actualPin == expectedPin ? '✅ MATCH' : '❌ MISMATCH'}");
+
+    socket.destroy();
+    return actualPin == expectedPin;
+  } catch (e) {
+    Log.print("❌ خطأ أثناء الاتصال أو الفحص: $e");
+    return false;
+  }
+}
+
+/// تحويل المفتاح العام إلى بصمة SHA-256
+List<int> sha256Convert(Uint8List der) {
+  return sha256.convert(der).bytes;
+}

siro_rider/lib/controller/auth/google_sign.dart

@@ -0,0 +1,149 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:get/get.dart';
+import 'package:google_sign_in/google_sign_in.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+import '../../constant/box_name.dart';
+import '../../constant/links.dart';
+import '../../main.dart';
+import '../../print.dart';
+import '../functions/crud.dart';
+import '../../onbording_page.dart';
+import 'login_controller.dart';
+
+class GoogleSignInHelper {
+  // ✅ GoogleSignIn singleton
+  static final GoogleSignIn _signIn = GoogleSignIn.instance;
+
+  static GoogleSignInAccount? _lastUser;
+
+  /// 👇 استدعها في main() مرة واحدة
+  static Future<void> init() async {
+    await _signIn.initialize(
+      serverClientId:
+          '594687661098-2u640akrb3k7sak5t0nqki6f4v6hq1bq.apps.googleusercontent.com',
+    );
+
+    // Events listener
+    _signIn.authenticationEvents.listen((event) async {
+      if (event is GoogleSignInAuthenticationEventSignIn) {
+        _lastUser = event.user;
+        await _handleSignUp(event.user);
+      } else if (event is GoogleSignInAuthenticationEventSignOut) {
+        _lastUser = null;
+      }
+    });
+
+    // silent login if possible
+    try {
+      await _signIn.attemptLightweightAuthentication();
+    } catch (e) {
+      Log.print("Error: $e");
+    }
+  }
+
+  /// ✅ تسجيل دخول عادي
+  static Future<GoogleSignInAccount?> signIn() async {
+    try {
+      final user =
+          await _signIn.authenticate(scopeHint: const ['email', 'profile']);
+      _lastUser = user;
+      await _handleSignUp(user);
+
+      // اطبع القيم (للتأكد)
+      Log.print("Google ID: ${user.id}");
+      Log.print("Email: ${user.email}");
+      Log.print("Name: ${user.displayName}");
+      Log.print("Photo: ${user.photoUrl}");
+      return user;
+    } on PlatformException catch (e) {
+      if (e.code == 'sign_in_required') {
+        await showGooglePlayServicesError();
+      }
+      return null;
+    } catch (e) {
+      await addError("Google Sign-In error: $e", "signIn()");
+      return null;
+    }
+  }
+
+  /// ✅ تسجيل دخول مخصص لشاشة Login (مع استدعاء الكنترولر)
+  static Future<GoogleSignInAccount?> signInFromLogin() async {
+    await init();
+    final user = await signIn();
+    if (user != null) {
+      await Get.put(LoginController()).loginUsingCredentials(
+        box.read(BoxName.passengerID).toString(),
+        box.read(BoxName.email).toString(),
+      );
+    }
+    return user;
+  }
+
+  /// ✅ طلب سكوبات إضافية (بديل withScopes القديم)
+  static Future<void> requestExtraScopes(List<String> scopes) async {
+    final user = _lastUser;
+    if (user == null) return;
+    await user.authorizationClient.authorizeScopes(scopes);
+  }
+
+  /// ✅ تسجيل خروج
+  static Future<void> signOut() async {
+    await _signIn.signOut();
+    await _handleSignOut();
+  }
+
+  static GoogleSignInAccount? getCurrentUser() => _lastUser;
+
+  // ================= Helpers ==================
+
+  static Future<void> _handleSignUp(GoogleSignInAccount user) async {
+    box.write(BoxName.passengerID, user.id);
+    box.write(BoxName.email, user.email);
+    box.write(BoxName.name, user.displayName ?? '');
+    box.write(BoxName.passengerPhotoUrl, user.photoUrl ?? '');
+  }
+
+  static Future<void> _handleSignOut() async {
+    box.erase();
+
+    Get.offAll(OnBoardingPage());
+  }
+
+  static Future<void> addError(String error, String where) async {
+    await CRUD().post(link: AppLink.addError, payload: {
+      'error': error,
+      'userId': box.read(BoxName.driverID) ?? box.read(BoxName.passengerID),
+      'userType': box.read(BoxName.driverID) != null ? 'Driver' : 'Passenger',
+      'phone': box.read(BoxName.phone) ?? box.read(BoxName.phoneDriver),
+      'device': where,
+    });
+  }
+
+  static Future<void> showGooglePlayServicesError() async {
+    const playStoreUrl =
+        'https://play.google.com/store/apps/details?id=com.google.android.gms&hl=en_US';
+    final uri = Uri.parse(playStoreUrl);
+    if (await canLaunchUrl(uri)) {
+      await launchUrl(uri);
+    } else {
+      showDialog(
+        context: Get.context!,
+        builder: (context) => AlertDialog(
+          title: Text('Error'.tr),
+          content: Text(
+            'Could not open the Google Play Store. Please update Google Play Services manually.'
+                .tr,
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.pop(context),
+              child: Text('Close'.tr),
+            ),
+          ],
+        ),
+      );
+    }
+  }
+}

siro_rider/lib/controller/auth/login_controller.dart

@@ -0,0 +1,526 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:siro_rider/constant/api_key.dart';
+import 'package:siro_rider/controller/firebase/firbase_messge.dart';
+import 'package:siro_rider/views/auth/otp_page.dart';
+import 'package:siro_rider/views/widgets/error_snakbar.dart';
+import 'package:http/http.dart' as http;
+
+import 'package:siro_rider/constant/info.dart';
+import 'package:siro_rider/controller/functions/add_error.dart';
+import 'package:siro_rider/views/auth/login_page.dart';
+
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:siro_rider/constant/box_name.dart';
+import 'package:siro_rider/constant/links.dart';
+import 'package:siro_rider/controller/functions/crud.dart';
+import 'package:siro_rider/main.dart';
+import 'package:siro_rider/views/home/map_page_passenger.dart';
+
+import 'package:location/location.dart';
+
+import '../../env/env.dart';
+import '../../print.dart';
+import '../../views/auth/otp_token_page.dart';
+import '../functions/encrypt_decrypt.dart';
+import '../functions/package_info.dart';
+
+class LoginController extends GetxController {
+  final formKey = GlobalKey<FormState>();
+  final formKeyAdmin = GlobalKey<FormState>();
+  TextEditingController emailController = TextEditingController();
+  TextEditingController phoneController = TextEditingController();
+  TextEditingController passwordController = TextEditingController();
+  TextEditingController adminPasswordController = TextEditingController();
+  TextEditingController adminNameController = TextEditingController();
+  bool isAgreeTerms = false;
+  bool isloading = false;
+  late int isTest = 1;
+  void changeAgreeTerm() {
+    isAgreeTerms = !isAgreeTerms;
+    update();
+  }
+
+  var dev = '';
+  @override
+  void onInit() async {
+    // Log.print('box.read(BoxName.isTest): ${box.read(BoxName.isTest)}');
+    box.write(BoxName.countryCode, 'Syria');
+    FirebaseMessagesController().getToken();
+    super.onInit();
+  }
+
+  void saveAgreementTerms() {
+    box.write(BoxName.agreeTerms, 'agreed');
+    update();
+  }
+
+  void saveCountryCode(String countryCode) {
+    box.write(BoxName.countryCode, countryCode);
+    update();
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+// LoginController — دوال إدارة الـ JWT
+// ───────────────────────────────────────────────────────────────
+// لا تغيير على اسم الكلاس أو أسماء الدوال
+// ═══════════════════════════════════════════════════════════════
+
+// داخل class LoginController
+
+  // ─────────────────────────────────────────────────────────────
+  // getJWT: الحصول على توكن للراكب
+  // ─────────────────────────────────────────────────────────────
+  // المنطق:
+  //   • firstTimeLoadKey != false  ← أول مرة يفتح التطبيق → loginFirstTime
+  //   • firstTimeLoadKey == false  ← مستخدم موجود         → loginJwtRider
+  // ─────────────────────────────────────────────────────────────
+  Future<void> getJWT() async {
+    // إذا كان التوكن الحالي لا يزال صالحاً، لا داعي لطلب واحد جديد
+    if (isTokenValid()) {
+      Log.print("JWT is still valid. Skipping request.");
+      return;
+    }
+
+    try {
+      dev = Platform.isAndroid ? 'android' : 'ios';
+
+      // تأكد إن البصمة محدّثة قبل أي طلب
+      await DeviceHelper.getDeviceFingerprint();
+      final String fp = box.read(BoxName.deviceFpEncrypted) ?? '';
+
+      if (box.read(BoxName.firstTimeLoadKey).toString() != 'false') {
+        // ── أول تسجيل ─────────────────────────────────────────
+        // نرسل البصمة المشفرة مع باقي البيانات
+        // السيرفر سيعمل hash لها ويخزنها في JWT payload
+        var payload = {
+          'id': box.read(BoxName.passengerID) ?? AK.newId,
+          'password': AK.passnpassenger,
+          'aud': '${AK.allowed}$dev',
+          'fingerPrint': fp,
+        };
+
+        var response = await http.post(
+          Uri.parse(AppLink.loginFirstTime),
+          body: payload,
+        );
+        Log.print('AppLink.loginFirstTime: ${AppLink.loginFirstTime}');
+
+        Log.print('payload: $payload');
+        Log.print('response: $response');
+
+        if (response.statusCode == 200) {
+          final decoded = jsonDecode(response.body);
+          final String? jwt = decoded['data'] != null
+              ? decoded['data']['jwt']
+              : (decoded['message'] != null
+                  ? decoded['message']['jwt']
+                  : decoded['jwt']);
+
+          if (jwt != null) {
+            // نشفر الـ JWT بالتشفير الثلاثي قبل التخزين في GetStorage
+            box.write(BoxName.jwt, c(jwt));
+          }
+
+          await EncryptionHelper.initialize();
+        }
+      } else {
+        // ── مستخدم موجود: تجديد التوكن ────────────────────────
+        await EncryptionHelper.initialize();
+
+        var payload = {
+          'id': box.read(BoxName.passengerID),
+          'fingerPrint': fp,
+          'aud': '${AK.allowed}$dev',
+        };
+
+        var response = await http.post(
+          Uri.parse(AppLink.loginJwtRider),
+          body: payload,
+        );
+        Log.print('AppLink.loginJwtRider: ${AppLink.loginJwtRider}');
+
+        Log.print('payload: $payload');
+        Log.print('response: ${response.body}');
+        if (response.statusCode == 200) {
+          final decoded = jsonDecode(response.body);
+          final String? jwt = decoded['data'] != null
+              ? decoded['data']['jwt']
+              : (decoded['message'] != null
+                  ? decoded['message']['jwt']
+                  : decoded['jwt']);
+
+          if (jwt != null) {
+            box.write(BoxName.jwt, c(jwt));
+          }
+        }
+      }
+    } catch (e) {
+      Log.print('Error in getJWT: $e');
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // التحقق من صلاحية التوكن يدوياً (بدون مكاتب خارجية)
+  // ─────────────────────────────────────────────────────────────
+  bool isTokenValid() {
+    try {
+      final String? encryptedJwt = box.read(BoxName.jwt);
+      if (encryptedJwt == null || encryptedJwt.isEmpty) {
+        Log.print("isTokenValid: No token found in storage.");
+        return false;
+      }
+
+      // 1. فك تشفير التوكن المخزن
+      final String jwtFull = r(encryptedJwt).toString();
+      final String jwt = jwtFull.split(Env.addd)[0];
+
+      final parts = jwt.split('.');
+      if (parts.length != 3) {
+        Log.print("isTokenValid: Invalid JWT format (parts: ${parts.length})");
+        return false;
+      }
+
+      // 2. فك Base64 للجزء الأوسط (Payload)
+      String payloadPart = parts[1];
+      while (payloadPart.length % 4 != 0) {
+        payloadPart += '=';
+      }
+
+      final String decodedPayload = utf8.decode(base64Url.decode(payloadPart));
+      final Map<String, dynamic> payload = jsonDecode(decodedPayload);
+
+      if (!payload.containsKey('exp')) {
+        Log.print("isTokenValid: No 'exp' claim in token.");
+        return false;
+      }
+
+      final int exp = payload['exp'];
+      final int now = DateTime.now().millisecondsSinceEpoch ~/ 1000;
+
+      Log.print("isTokenValid: Now=$now, Exp=$exp, Diff=${exp - now}s");
+
+      // اعتبار التوكن منتهي قبل دقيقة للأمان
+      final bool valid = exp > (now + 60);
+      Log.print("isTokenValid: Result=$valid");
+      return valid;
+    } catch (e) {
+      Log.print("isTokenValid Error: $e");
+      return false;
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // الفرق عن getJWT:
+  //   • يستخدم endpoint مختلف (loginWallet)
+  //   • يرجع hmac مع الـ jwt ويخزنه في GetStorage
+  //   • الـ JWT لا يُشفَّر ثلاثياً (يُستخدم مباشرة في الـ header)
+  // ─────────────────────────────────────────────────────────────
+  Future<String?> getJwtWallet() async {
+    dev = Platform.isAndroid ? 'android' : 'ios';
+
+    final String fp = box.read(BoxName.deviceFpEncrypted) ?? '';
+
+    var payload = {
+      'id': box.read(BoxName.passengerID),
+      'password': AK.passnpassenger,
+      'aud': '${AK.allowedWallet}$dev',
+      'fingerPrint': fp,
+    };
+
+    var response = await http.post(
+      Uri.parse(AppLink.loginJwtWalletRider),
+      body: payload,
+    );
+
+    Log.print('AppLink.loginJwtWalletRider: ${AppLink.loginJwtWalletRider}');
+    Log.print('response wallet: ${response.body}');
+
+    if (response.statusCode == 200) {
+      final decoded = jsonDecode(response.body);
+
+      // ← الإصلاح: نقرأ من message أو data أو root
+      final inner = decoded['data'] ?? decoded['message'] ?? decoded;
+
+      final String? jwt = inner['jwt'];
+      final String? hmac = inner['hmac'];
+
+      Log.print('jwt extracted: $jwt');
+      Log.print('hmac extracted: $hmac');
+
+      if (hmac != null) {
+        box.write(BoxName.hmac, hmac);
+      }
+
+      return jwt;
+    }
+
+    return null;
+  }
+
+  Future<void> loginUsingCredentials(String passengerID, String email) async {
+    isloading = true;
+    update();
+    // await getJWT();
+    Log.print("LoginController.loginUsingCredentials: ");
+    try {
+      // 1) استعلام تسجيل الدخول
+      final res = await CRUD().get(
+        link: AppLink.loginFromGooglePassenger,
+        payload: {
+          'email': email,
+          'id': passengerID, // استخدم المعامل مباشرة
+          'platform': Platform.isAndroid ? 'android' : 'ios',
+          'appName': AppInformation.appName,
+        },
+      );
+
+      // 2) فك JSON مرة واحدة والتحقق من النجاح
+      final decoded = jsonDecode(res);
+      if (decoded is! Map || decoded.isEmpty) return;
+
+      if (decoded['status'] == 'failure' || decoded['status'] == 'Failure') {
+        Get.snackbar("User does not exist.".tr, '',
+            backgroundColor: Colors.red);
+        return;
+      }
+
+      final status = (decoded['status'] ?? '').toString();
+      final data = (decoded['data'] as List?)?.firstOrNull as Map? ?? {};
+      if (status != 'success' || data['verified'].toString() != '1') {
+        // غير مُفعل -> أذهب للتسجيل بالـ SMS
+        Get.offAll(() => PhoneNumberScreen());
+        return;
+      }
+
+      // 3) كتابة القيم (خفيفة)
+      box.write(BoxName.isVerified, '1');
+      box.write(BoxName.email, data['email']);
+      box.write(BoxName.phone, data['phone']);
+      box.write(BoxName.name, data['first_name']);
+      box.write(BoxName.isTest, '1');
+      box.write(BoxName.package, data['package']);
+      box.write(BoxName.promo, data['promo']);
+      box.write(BoxName.discount, data['discount']);
+      box.write(BoxName.validity, data['validity']);
+      box.write(BoxName.isInstall, data['isInstall'] ?? 'none');
+      box.write(BoxName.isGiftToken, data['isGiftToken'] ?? 'none');
+      if (data['inviteCode'] != null) {
+        box.write(BoxName.inviteCode, data['inviteCode'].toString());
+      }
+      // مهم: تأكد من passengerID في الـ box
+      box.write(BoxName.passengerID, passengerID);
+
+      // 4) فحص ما إذا كان التوكن موجوداً في رد الـ Login المدمج (V3 Optimization)
+      String? serverFCM;
+      String? serverFP;
+
+      var userData = decoded['data'] is List
+          ? (decoded['data'] as List).firstOrNull
+          : decoded['data'];
+      if (userData is Map && userData['fcm_token'] != null) {
+        serverFCM = userData['fcm_token'].toString();
+        serverFP = userData['fcm_fingerprint']?.toString() ?? '';
+        Log.print(
+            "✅ FCM Token found in Login response. Skipping separate getTokens call.");
+      }
+
+      // إذا لم يكن موجوداً (توافقية قديمة)، نقوم بطلبه
+      String? tokenResp;
+      if (serverFCM == null) {
+        tokenResp = await CRUD().get(
+            link: AppLink.getTokens, payload: {'passengerID': passengerID});
+      }
+
+      final localFP = (await DeviceHelper.getDeviceFingerprint()).toString();
+      await storage.write(key: BoxName.fingerPrint, value: localFP);
+      await box.write(BoxName.firstTimeLoadKey, 'false');
+
+      // ── 5. المقارنة: FCM token + fingerprint ──────────────────────
+      if (email != '962798583052@intaleqapp.com') {
+        if (serverFCM == null &&
+            tokenResp != null &&
+            tokenResp != 'failure' &&
+            tokenResp != 'error') {
+          final tokenJson = jsonDecode(tokenResp);
+          final serverData = tokenJson['data'] ?? tokenJson['message'];
+          if (serverData is Map) {
+            serverFCM = serverData['token']?.toString() ?? '';
+            serverFP = serverData['fingerPrint']?.toString() ?? '';
+          }
+        }
+
+        if (serverFCM != null && serverFCM.isNotEmpty) {
+          final localFCM = (box.read(BoxName.tokenFCM) ?? '').toString();
+
+          // ── اختلاف أي منهما = جهاز مختلف أو تثبيت جديد ─────────
+          final fcmChanged = serverFCM != localFCM;
+          final fpChanged =
+              serverFP != null && serverFP.isNotEmpty && serverFP != localFP;
+
+          if (fcmChanged || fpChanged) {
+            mySnackbarInfo('Device Change Detected'.tr);
+            await Get.to(() => OtpVerificationPage(
+                  phone: data['phone'].toString(),
+                  deviceToken: localFP,
+                  token: tokenResp ?? '',
+                  ptoken: serverFCM ?? '', // نمرر FCM القديم للـ OTP controller
+                ));
+            return;
+          }
+        }
+      }
+
+      // 6) منطق الدعوة (إن وُجد) ثم الانتقال
+      final invite = box.read(BoxName.inviteCode)?.toString() ?? 'none';
+      final isInstall = box.read(BoxName.isInstall)?.toString() ?? '0';
+
+      if (invite != 'none' && isInstall != '1') {
+        try {
+          await CRUD().post(link: AppLink.updatePassengersInvitation, payload: {
+            "inviteCode": invite,
+            "passengerID": passengerID,
+          });
+          await Get.defaultDialog(
+            title: 'Invitation Used'.tr,
+            middleText: "Your invite code was successfully applied!".tr,
+            textConfirm: "OK".tr,
+            confirmTextColor: Colors.white,
+            onConfirm: () async {
+              try {
+                await CRUD().post(link: AppLink.addPassengersPromo, payload: {
+                  "promoCode":
+                      'I-${(box.read(BoxName.name)).toString().split(' ').first}',
+                  "amount": '25',
+                  "passengerID": passengerID,
+                  "description": 'promo first'
+                });
+              } catch (e) {
+                addError(
+                    e.toString(), 'promo on invitation in login_controller');
+              } finally {
+                Get.offAll(() => const MapPagePassenger());
+              }
+            },
+          );
+          return;
+        } catch (_) {
+          // حتى لو فشل، كمل للصفحة الرئيسية
+        }
+      }
+
+      Get.offAll(() => const MapPagePassenger());
+    } catch (e) {
+      addError('$e', 'loginUsingCredentials');
+      Get.snackbar('Error', e.toString(), backgroundColor: Colors.redAccent);
+    } finally {
+      isloading = false;
+      update();
+    }
+  }
+
+  // Future<bool?> _confirmDeviceChangeDialog() {
+  //   return Get.defaultDialog<bool>(
+  //     barrierDismissible: false,
+  //     title: 'Device Change Detected'.tr,
+  //     middleText: 'Please verify your identity'.tr,
+  //     textConfirm: 'Verify'.tr,
+  //     confirmTextColor: Colors.white,
+  //     onConfirm: () => Get.back(result: true),
+  //     textCancel: 'Cancel'.tr,
+  //     onCancel: () => Get.back(result: false),
+  //   );
+  // }
+
+  void login() async {
+    isloading = true;
+    update();
+    var res =
+        await CRUD().get(link: AppLink.loginFromGooglePassenger, payload: {
+      'email': (emailController.text),
+      'id': passwordController.text,
+      "platform": Platform.isAndroid ? 'android' : 'ios',
+      "appName": AppInformation.appName,
+    });
+
+    isloading = false;
+    update();
+    if (res == 'Failure') {
+      //Failure
+      Get.offAll(() => LoginPage());
+      isloading = false;
+      update();
+      // Get.snackbar("User does not exist.".tr, '', backgroundColor: Colors.red);
+    } else {
+      var jsonDecoeded = jsonDecode(res);
+      if (jsonDecoeded.isNotEmpty) {
+        if (jsonDecoeded['status'] == 'success' &&
+            jsonDecoeded['data'][0]['verified'].toString() == '1') {
+          //
+          box.write(BoxName.isVerified, '1');
+          box.write(BoxName.email, jsonDecoeded['data'][0]['email']);
+          box.write(BoxName.name, jsonDecoeded['data'][0]['first_name']);
+          box.write(BoxName.phone, jsonDecoeded['data'][0]['phone']);
+          box.write(BoxName.passengerID, passwordController.text);
+          // var token = await CRUD().get(link: AppLink.getTokens, payload: {
+          //   'passengerID': box.read(BoxName.passengerID).toString()
+          // });
+          // await updateAppTester(AppInformation.appName);
+
+          Get.offAll(() => const MapPagePassenger());
+        } else {
+          // Get.offAll(() => SmsSignupEgypt());
+          // Get.snackbar(jsonDecoeded['status'], jsonDecoeded['data'],
+          //     backgroundColor: Colors.redAccent);
+          isloading = false;
+          update();
+        }
+      } else {
+        isloading = false;
+        update();
+      }
+    }
+  }
+
+  void goToMapPage() {
+    if (box.read(BoxName.email) != null) {
+      Get.offAll(() => const MapPagePassenger());
+    }
+  }
+
+  final location = Location();
+
+  // late PermissionStatus permissionGranted = PermissionStatus.denied;
+  Future<void> getLocationPermission() async {
+    bool serviceEnabled;
+    PermissionStatus permissionGranted;
+
+    // Check if location services are enabled
+    serviceEnabled = await location.serviceEnabled();
+    if (!serviceEnabled) {
+      serviceEnabled = await location.requestService();
+      if (!serviceEnabled) {
+        // Location services are still not enabled, handle the error
+        return;
+      }
+    }
+
+    // Check if the app has permission to access location
+    permissionGranted = await location.hasPermission();
+    if (permissionGranted == PermissionStatus.denied) {
+      permissionGranted = await location.requestPermission();
+      if (permissionGranted != PermissionStatus.granted) {
+        // Location permission is still not granted, handle the error
+        permissionGranted = await location.requestPermission();
+        return;
+      }
+    }
+    if (permissionGranted.toString() == 'PermissionStatus.granted') {
+      box.write(BoxName.locationPermission, 'true');
+    }
+    update();
+  }
+}

siro_rider/lib/controller/auth/onboarding_controller.dart

@@ -0,0 +1,43 @@
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:siro_rider/constant/box_name.dart';
+import 'package:siro_rider/main.dart';
+import 'package:siro_rider/views/auth/login_page.dart';
+
+import '../../models/model/onboarding_model.dart';
+
+abstract class OnBoardingController extends GetxController {
+  next();
+  onPageChanged(int index);
+}
+
+class OnBoardingControllerImp extends OnBoardingController {
+  late PageController pageController;
+
+  int currentPage = 0;
+
+  @override
+  next() {
+    currentPage++;
+
+    if (currentPage > onBoardingList.length - 1) {
+      box.write(BoxName.onBoarding, 'yes');
+      Get.offAll(() => LoginPage());
+    } else {
+      pageController.animateToPage(currentPage,
+          duration: const Duration(milliseconds: 900), curve: Curves.easeInOut);
+    }
+  }
+
+  @override
+  onPageChanged(int index) {
+    currentPage = index;
+    update();
+  }
+
+  @override
+  void onInit() {
+    pageController = PageController();
+    super.onInit();
+  }
+}

siro_rider/lib/controller/auth/otp_controller.dart

@@ -0,0 +1,210 @@
+import 'package:siro_rider/constant/links.dart';
+import 'package:siro_rider/views/home/map_page_passenger.dart';
+import 'package:get/get.dart';
+import '../../../constant/box_name.dart';
+import '../../../main.dart';
+import '../../../print.dart';
+import '../../views/auth/otp_page.dart';
+import '../../views/widgets/error_snakbar.dart';
+import '../functions/crud.dart';
+import '../functions/package_info.dart';
+import 'login_controller.dart';
+
+// --- Helper Class for Phone Authentication ---
+
+class PhoneAuthHelper {
+  // Define your server URLs
+  static final String _baseUrl = '${AppLink.server}/auth/syria/';
+  static final String _sendOtpUrl = '${_baseUrl}sendWhatsOpt.php';
+  static final String _verifyOtpUrl = '${_baseUrl}verifyOtp.php';
+  static final String _registerUrl = '${_baseUrl}register_passenger.php';
+
+  static String formatSyrianPhone(String phone) {
+    // Remove spaces, symbols, +, -, ()
+    phone = phone.replaceAll(RegExp(r'[ \-\(\)\+]'), '').trim();
+
+    // Normalize 00963 → 963
+    if (phone.startsWith('00963')) {
+      phone = phone.replaceFirst('00963', '963');
+    }
+
+    // Normalize 0963 → 963
+    if (phone.startsWith('0963')) {
+      phone = phone.replaceFirst('0963', '963');
+    }
+
+    // NEW: Fix 96309xxxx → 9639xxxx
+    if (phone.startsWith('96309')) {
+      phone = '9639' + phone.substring(5); // remove the "0" after 963
+    }
+
+    // If starts with 9630 → correct to 9639
+    if (phone.startsWith('9630')) {
+      phone = '9639' + phone.substring(4);
+    }
+
+    // If already in correct format: 9639xxxxxxxx
+    if (phone.startsWith('9639') && phone.length == 12) {
+      return phone;
+    }
+
+    // If starts with 963 but missing the 9
+    if (phone.startsWith('963') && phone.length > 3) {
+      // Ensure it begins with 9639
+      if (!phone.startsWith('9639')) {
+        phone = '9639' + phone.substring(3);
+      }
+      return phone;
+    }
+
+    // If starts with 09xxxxxxxx → 9639xxxxxxxx
+    if (phone.startsWith('09')) {
+      return '963' + phone.substring(1);
+    }
+
+    // If 9xxxxxxxx (9 digits)
+    if (phone.startsWith('9') && phone.length == 9) {
+      return '963' + phone;
+    }
+
+    // If starts with incorrect 0xxxxxxx → assume Syrian and fix
+    if (phone.startsWith('0') && phone.length == 10) {
+      return '963' + phone.substring(1);
+    }
+
+    return phone;
+  }
+
+  /// Sends an OTP to the provided phone number.
+  static Future<bool> sendOtp(String phoneNumber) async {
+    try {
+      // إصلاح الرقم قبل الإرسال
+      final fixedPhone = formatSyrianPhone(phoneNumber);
+
+      final response = await CRUD().post(
+        link: _sendOtpUrl,
+        payload: {'receiver': fixedPhone}, // ← ← استخدام الرقم المُعدّل
+      );
+
+      if (response != 'failure') {
+        final data = response;
+
+        if (data['status'] == 'success') {
+          mySnackbarSuccess('An OTP has been sent to your number.'.tr);
+          return true;
+        } else {
+          mySnackeBarError(data['message'] ?? 'Failed to send OTP.');
+          return false;
+        }
+      } else {
+        mySnackeBarError('Server error. Please try again.'.tr);
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Verifies the OTP and logs the user in.
+
+  static Future<void> verifyOtp(String phoneNumber, String otpCode) async {
+    try {
+      final fixedPhone = formatSyrianPhone(phoneNumber);
+      final response = await CRUD().post(
+        link: _verifyOtpUrl,
+        payload: {
+          'phone_number': fixedPhone,
+          'otp': otpCode,
+        },
+      );
+
+      if (response != 'failure') {
+        final data = (response);
+        Log.print('data: ${data}');
+
+        if (data['status'] == 'success') {
+          final isRegistered = data['message']['isRegistered'] ?? false;
+          Log.print('isRegistered: ${isRegistered}');
+
+          if (isRegistered) {
+            // ✅ المستخدم موجود مسبقاً -> تسجيل دخول مباشر
+            await _handleSuccessfulLogin(data['message']['passenger']);
+          } else {
+            // ✅ مستخدم جديد -> الذهاب لصفحة التسجيل
+            mySnackbarSuccess(
+                'Phone verified. Please complete registration.'.tr);
+            Get.to(() => RegistrationScreen(phoneNumber: phoneNumber));
+          }
+        } else {
+          mySnackeBarError(data['message']);
+        }
+      } else {
+        mySnackeBarError('Server error. Please try again.'.tr);
+      }
+    } catch (e) {
+      mySnackeBarError('An error occurred: $e');
+    }
+  }
+
+  static Future<void> _addTokens() async {
+    String fingerPrint = await DeviceHelper.getDeviceFingerprint();
+
+    var res = await CRUD()
+        // this for register and login //
+        .post(link: "${AppLink.server}/ride/firebase/addToken.php", payload: {
+      'token': (box.read(BoxName.tokenFCM.toString())),
+      'passengerID': box.read(BoxName.passengerID).toString(),
+      "fingerPrint": fingerPrint
+    });
+    Log.print('res token: ${res}');
+  }
+
+  static Future<void> registerUser({
+    required String phoneNumber,
+    required String firstName,
+    required String lastName,
+    String? email,
+  }) async {
+    try {
+      final response = await CRUD().post(
+        link: _registerUrl,
+        payload: {
+          'phone_number': phoneNumber,
+          'first_name': firstName,
+          'last_name': lastName,
+          'email': email ?? '', // Send empty string if null
+        },
+      );
+      final data = (response);
+      if (data != 'failure') {
+        // Registration successful, log user in
+
+        await _handleSuccessfulLogin(data['message']['data']);
+      } else {
+        mySnackeBarError(
+            "User with this phone number or email already exists.".tr);
+      }
+    } catch (e) {
+      Log.print('e: ${e}');
+      mySnackeBarError('An error occurred: $e');
+    }
+  }
+
+  static Future<void> _handleSuccessfulLogin(
+      Map<String, dynamic> userData) async {
+    mySnackbarSuccess('Welcome, ${userData['first_name']}!');
+
+    // Save user data to local storage (Hive box) using new keys
+    box.write(BoxName.passengerID, userData['id']);
+    box.write(BoxName.name, userData['first_name']);
+    box.write(BoxName.lastName, userData['last_name']);
+    box.write(BoxName.email, userData['email']);
+    box.write(BoxName.phone, userData['phone']);
+    box.write(BoxName.isVerified, '1');
+    await _addTokens();
+    await Get.put(LoginController()).loginUsingCredentials(
+      box.read(BoxName.passengerID).toString(),
+      box.read(BoxName.email).toString(),
+    ); // Navigate to home
+  }
+}

siro_rider/lib/controller/auth/register_controller.dart

@@ -0,0 +1,367 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:math';
+
+import 'package:siro_rider/constant/colors.dart';
+import 'package:siro_rider/controller/auth/login_controller.dart';
+import 'package:siro_rider/controller/functions/add_error.dart';
+import 'package:siro_rider/controller/functions/encrypt_decrypt.dart';
+import 'package:siro_rider/views/home/map_page_passenger.dart';
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:siro_rider/constant/links.dart';
+import 'package:siro_rider/constant/style.dart';
+import 'package:siro_rider/controller/functions/crud.dart';
+import 'package:siro_rider/views/auth/login_page.dart';
+import 'package:siro_rider/views/widgets/elevated_btn.dart';
+
+import '../../constant/box_name.dart';
+import '../../main.dart';
+import '../../print.dart';
+import '../../views/auth/verify_email_page.dart';
+import '../../views/widgets/mydialoug.dart';
+import '../functions/sms_controller.dart';
+
+class RegisterController extends GetxController {
+  final formKey = GlobalKey<FormState>();
+  final formKey3 = GlobalKey<FormState>();
+
+  TextEditingController firstNameController = TextEditingController();
+  TextEditingController lastNameController = TextEditingController();
+  TextEditingController emailController = TextEditingController();
+  TextEditingController phoneController = TextEditingController();
+  TextEditingController passwordController = TextEditingController();
+  TextEditingController siteController = TextEditingController();
+  // TextEditingController verfyCode = TextEditingController();
+  TextEditingController verifyCode = TextEditingController();
+  int remainingTime = 300; // 5 minutes in seconds
+  bool isSent = false;
+  bool isLoading = false;
+  Timer? _timer;
+  String birthDate = 'Birth Date'.tr;
+  String gender = 'Male'.tr;
+  @override
+  void onInit() {
+    super.onInit();
+  }
+
+  void startTimer() {
+    _timer?.cancel(); // Cancel any existing timer
+    _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
+      if (remainingTime > 0) {
+        remainingTime--;
+      } else {
+        timer.cancel();
+      }
+    });
+  }
+
+  getBirthDate() {
+    Get.defaultDialog(
+        title: 'Select Date'.tr,
+        titleStyle: AppStyle.title,
+        content: SizedBox(
+          width: 300,
+          child: CalendarDatePicker(
+            initialDate:
+                DateTime.now().subtract(const Duration(days: 14 * 365)),
+            firstDate: DateTime.parse('1940-06-01'),
+            lastDate: DateTime.now().subtract(const Duration(days: 14 * 365)),
+            onDateChanged: (date) {
+              // Get the selected date and convert it to a DateTime object
+              DateTime dateTime = date;
+              // Call the getOrders() function from the controller
+              birthDate = dateTime.toString().split(' ')[0];
+              update();
+            },
+
+            // onDateChanged: (DateTime value) {},
+          ),
+        ),
+        confirm: MyElevatedButton(title: 'Ok'.tr, onPressed: () => Get.back()));
+  }
+
+  void changeGender(String value) {
+    gender = value;
+    update();
+  }
+
+  bool isValidEgyptianPhoneNumber(String phoneNumber) {
+    // Remove any whitespace from the phone number
+    phoneNumber = phoneNumber.replaceAll(RegExp(r'\s+'), '');
+
+    // Check if the phone number has exactly 11 digits
+    if (phoneNumber.length != 11) {
+      return false;
+    }
+
+    // Check if the phone number starts with 010, 011, 012, or 015
+    RegExp validPrefixes = RegExp(r'^01[0125]\d{8}$');
+
+    return validPrefixes.hasMatch(phoneNumber);
+  }
+
+  bool isValidPhoneNumber(String phoneNumber) {
+    // Remove any whitespace from the phone number
+    phoneNumber = phoneNumber.replaceAll(RegExp(r'\s+'), '');
+
+    // Check if the phone number has at least 10 digits
+    if (phoneNumber.length < 10) {
+      return false;
+    }
+
+    // Check for valid prefixes (modify this to match your use case)
+    RegExp validPrefixes = RegExp(r'^[0-9]+$');
+
+    // Check if the phone number contains only digits
+    return validPrefixes.hasMatch(phoneNumber);
+  }
+
+  sendOtpMessage() async {
+    SmsEgyptController smsEgyptController;
+    isLoading = true;
+    update();
+    try {
+      // Initialize SmsEgyptController
+      smsEgyptController = Get.put(SmsEgyptController());
+
+      isLoading = true;
+      update();
+
+      // Get phone number from controller
+      String phoneNumber = phoneController.text;
+
+      // Check if the phone number is from Egypt (Assuming Egyptian numbers start with +20)
+
+      if (phoneController.text.isNotEmpty) {
+        bool isEgyptianNumber = phoneNumber.startsWith('+20');
+        if (isEgyptianNumber && phoneNumber.length == 13) {
+          // Check if the phone number is already verified
+          var responseChecker = await CRUD().post(
+            link: AppLink.checkPhoneNumberISVerfiedPassenger,
+            payload: {
+              'phone_number': (phoneNumber),
+              'email': box.read(BoxName.email),
+            },
+          );
+
+          if (responseChecker != 'failure') {
+            var data = jsonDecode(responseChecker);
+
+            // If the phone number is already verified
+            if (data['message'][0]['verified'].toString() == '1') {
+              Get.snackbar('Phone number is verified before'.tr, '',
+                  backgroundColor: AppColor.greenColor);
+              box.write(BoxName.isVerified, '1');
+              box.write(BoxName.phone, (phoneNumber));
+              Get.offAll(const MapPagePassenger());
+            } else {
+              await sendOtp(phoneNumber, isEgyptianNumber, smsEgyptController);
+            }
+          } else {
+            await sendOtp(phoneNumber, isEgyptianNumber, smsEgyptController);
+          }
+        } else if (phoneNumber.length > 9) {
+          sendOtp(phoneNumber, isEgyptianNumber, smsEgyptController);
+        }
+      } else {
+        MyDialog().getDialog(
+            'Error'.tr, 'Phone number must be exactly 11 digits long'.tr, () {
+          Get.back();
+        });
+        // sendOtp(
+        //     phoneNumber, randomNumber, isEgyptianNumber, smsEgyptController);
+      }
+    } catch (e) {
+      // Handle error
+    } finally {
+      isLoading = false;
+      update();
+    }
+  }
+
+// Helper function to send OTP or WhatsApp message based on phone number location
+  Future<void> sendOtp(String phoneNumber, bool isEgyptian,
+      SmsEgyptController controller) async {
+    // Trim any leading or trailing whitespace from the phone number
+    phoneNumber = phoneNumber.trim();
+    var dd = await CRUD().post(link: AppLink.sendVerifyOtpMessage, payload: {
+      'phone_number': (phoneNumber),
+    });
+    Log.print('dd: ${dd}');
+
+    // Common Registration Logic (extracted for reuse)
+    Future<void> registerUser() async {
+      await CRUD().post(link: AppLink.updatePhoneInvalidSMSPassenger, payload: {
+        "phone_number": (Get.find<RegisterController>().phoneController.text)
+      });
+
+      box.write(BoxName.phone, (phoneController.text));
+
+      var nameParts = (box.read(BoxName.name)).toString().split(' ');
+      var firstName = nameParts.isNotEmpty ? nameParts[0] : 'unknown';
+      var lastName = nameParts.length > 1 ? nameParts[1] : 'unknown';
+
+      var payload = {
+        'id': box.read(BoxName.passengerID),
+        'phone': (phoneController.text),
+        'email': box.read(BoxName.email),
+        'password':
+            ('unknown'), //Consider if you *really* want to store 'unknown' passwords
+        'gender': ('unknown'),
+        'birthdate': ('2002-01-01'),
+        'site': box.read(BoxName.passengerPhotoUrl) ?? 'unknown',
+        'first_name': (firstName),
+        'last_name': (lastName),
+      };
+
+      var res1 = await CRUD().post(
+        link: AppLink.signUp,
+        payload: payload,
+      );
+
+      if (res1 != 'failure') {
+        //Multi-server signup (moved inside the successful registration check)
+        // if (AppLink.IntaleqAlexandriaServer != AppLink.IntaleqSyriaServer) {
+        //   List<Future> signUp = [
+        //     CRUD().post(
+        //       link: '${AppLink.IntaleqAlexandriaServer}/auth/signup.php',
+        //       payload: payload,
+        //     ),
+        //     CRUD().post(
+        //       link: '${AppLink.IntaleqGizaServer}/auth/signup.php',
+        //       payload: payload,
+        //     )
+        //   ];
+        //   await Future.wait(signUp); // Wait for both sign-ups to complete.
+        // }
+
+        box.write(BoxName.isVerified, '1');
+        box.write(
+            BoxName.isFirstTime, '0'); //Double-check the logic for isFirstTime
+        box.write(BoxName.phone, (phoneController.text));
+
+        Get.put(LoginController()).loginUsingCredentials(
+          box.read(BoxName.passengerID).toString(),
+          box.read(BoxName.email).toString(),
+        );
+      }
+    }
+
+    if (isEgyptian) {
+      // verifySMSCode();
+      // await registerUser(); // Use the common registration logic
+      // await controller.sendSmsEgypt(phoneNumber, otp.toString()); // Optional: Send SMS if Egyptian
+    } else if (phoneController.text.toString().length >= 10) {
+      await registerUser(); // Use the common registration logic for non-Egyptian users as well.
+      // this for whatsapp messsage  // Optional: Send WhatsApp message
+      // await CRUD().sendWhatsAppAuth(phoneNumber, otp.toString());
+    }
+
+    isLoading = false;
+    isSent = true;
+    remainingTime = 300;
+    update(); // Reset to 5 minutes
+    // startTimer(); // Consider whether you need a timer here, or if it's handled elsewhere.
+  }
+
+  verifySMSCode() async {
+    try {
+      if (formKey3.currentState!.validate()) {
+        var res = await CRUD().post(link: AppLink.verifyOtpPassenger, payload: {
+          'phone_number': phoneController.text,
+          'token': verifyCode.text,
+        });
+
+        if (res != 'failure') {
+          box.write(BoxName.phone, (phoneController.text));
+          var nameParts = (box.read(BoxName.name)).toString().split(' ');
+          var firstName = nameParts.isNotEmpty ? nameParts[0] : 'unknown';
+          var lastName = nameParts.length > 1 ? nameParts[1] : 'unknown';
+
+          var payload = {
+            'id': box.read(BoxName.passengerID),
+            'phone': (phoneController.text),
+            'email': box.read(BoxName.email),
+            'password': 'unknown',
+            'gender': 'unknown',
+            'birthdate': '2002-01-01',
+            'site': box.read(BoxName.passengerPhotoUrl) ?? 'unknown',
+            'first_name': firstName,
+            'last_name': lastName,
+          };
+
+          var res1 = await CRUD().post(
+            link: AppLink.signUp,
+            payload: payload,
+          );
+
+          if (res1 != 'failure') {
+            box.write(BoxName.isVerified, '1');
+            box.write(BoxName.isFirstTime, '0');
+            box.write(BoxName.phone, (phoneController.text));
+
+            Get.put(LoginController()).loginUsingCredentials(
+              box.read(BoxName.passengerID).toString(),
+              box.read(BoxName.email).toString(),
+            );
+          } else {
+            Get.snackbar('Error'.tr,
+                "The email or phone number is already registered.".tr,
+                backgroundColor: Colors.redAccent);
+          }
+        } else {
+          Get.snackbar('Error'.tr, "phone not verified".tr,
+              backgroundColor: Colors.redAccent);
+        }
+      } else {
+        Get.snackbar('Error'.tr, "you must insert token code".tr,
+            backgroundColor: AppColor.redColor);
+      }
+    } catch (e) {
+      addError(e.toString(), 'passenger sign up ');
+      Get.snackbar('Error'.tr, "Something went wrong. Please try again.".tr,
+          backgroundColor: Colors.redAccent);
+    }
+  }
+
+  sendVerifications() async {
+    var res = await CRUD().post(link: AppLink.verifyEmail, payload: {
+      'email': emailController.text,
+      'token': verifyCode.text,
+    });
+    var dec = jsonDecode(res);
+    if (dec['status'] == 'success') {
+      Get.offAll(() => LoginPage());
+    }
+  }
+
+  void register() async {
+    if (formKey.currentState!.validate()) {
+      var res = await CRUD().post(link: AppLink.signUp, payload: {
+        'first_name': firstNameController.text.toString(),
+        'last_name': lastNameController.text.toString(),
+        'email': emailController.text.toString(),
+        'phone': phoneController.text.toString(),
+        'password': passwordController.text.toString(),
+        'gender': 'yet',
+        'site': siteController.text,
+        'birthdate': birthDate,
+      });
+      if (jsonDecode(res)['status'] == 'success') {
+        int randomNumber = Random().nextInt(100000) + 1;
+        await CRUD().post(link: AppLink.sendVerifyEmail, payload: {
+          'email': emailController.text,
+          'token': randomNumber.toString(),
+        });
+        Get.to(() => const VerifyEmailPage());
+      }
+    }
+  }
+
+  @override
+  void onClose() {
+    _timer?.cancel();
+    super.onClose();
+  }
+}

siro_rider/lib/controller/auth/token_otp_change_controller.dart

@@ -0,0 +1,114 @@
+import 'dart:async';
+
+import 'package:siro_rider/constant/box_name.dart';
+import 'package:siro_rider/constant/links.dart';
+import 'package:siro_rider/controller/functions/crud.dart';
+import 'package:siro_rider/main.dart';
+import 'package:get/get.dart';
+
+import '../../print.dart';
+import '../../views/home/map_page_passenger.dart';
+import '../firebase/firbase_messge.dart';
+import '../firebase/notification_service.dart';
+import '../functions/package_info.dart';
+
+class OtpVerificationController extends GetxController {
+  final String phone;
+  final String deviceToken;
+  final String token;
+  final otpCode = ''.obs;
+  final isLoading = false.obs;
+  final isVerifying = false.obs;
+  var canResend = false.obs;
+  var countdown = 120.obs;
+  Timer? _timer;
+
+  OtpVerificationController({
+    required this.phone,
+    required this.deviceToken,
+    required this.token,
+  });
+
+  @override
+  void onInit() {
+    super.onInit();
+    sendOtp(); // ترسل تلقائيًا عند فتح الصفحة
+    startCountdown();
+  }
+
+  void startCountdown() {
+    canResend.value = false;
+    countdown.value = 120;
+    _timer?.cancel();
+    _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
+      if (countdown.value > 0) {
+        countdown.value--;
+      } else {
+        canResend.value = true;
+        timer.cancel();
+      }
+    });
+  }
+
+  Future<void> sendOtp() async {
+    if (isLoading.value) return;
+    isLoading.value = true;
+    try {
+      final response = await CRUD().post(
+        link: '${AppLink.server}/auth/token_passenger/send_otp.php',
+        payload: {
+          'receiver': phone,
+          // 'device_token': deviceToken,
+        },
+      );
+
+      if (response != 'failure') {
+        isLoading.value = true;
+        // بإمكانك عرض رسالة نجاح هنا
+      } else {
+        Get.snackbar('Error'.tr, 'Failed to send OTP'.tr);
+      }
+    } catch (e) {
+      Get.snackbar('Error', e.toString());
+    } finally {
+      // isLoading.value = false;
+    }
+  }
+
+  Future<void> verifyOtp(String ptoken) async {
+    isVerifying.value = true;
+
+    try {
+      String fingerPrint = await DeviceHelper.getDeviceFingerprint();
+      final response = await CRUD().post(
+        link: '${AppLink.server}/auth/token_passenger/verify_otp.php',
+        payload: {
+          'phone_number': phone,
+          'otp': otpCode.value,
+          'token': box.read(BoxName.tokenFCM).toString(),
+          'fingerPrint': fingerPrint.toString(),
+        },
+      );
+
+      if (response != 'failure' && response['status'] == 'success') {
+        await NotificationService.sendNotification(
+          category: 'token change',
+          target: ptoken.toString(),
+          title: 'token change'.tr,
+          body: 'change device'.tr,
+          isTopic: false, // Important: this is a token
+          tone: 'cancel',
+          driverList: [],
+        );
+
+        Get.offAll(() => const MapPagePassenger());
+      } else {
+        Get.snackbar('Verification Failed', 'OTP is incorrect or expired');
+      }
+    } catch (e) {
+      Get.snackbar('Error', e.toString());
+    } finally {
+      isVerifying.value = false;
+    }
+  }
+}

siro_rider/lib/controller/auth/tokens_controller.dart

@@ -0,0 +1,38 @@
+import 'dart:convert';
+
+import 'package:get/get.dart';
+import 'package:http/http.dart' as http;
+
+import '../../constant/box_name.dart';
+import '../../constant/links.dart';
+import '../../main.dart';
+import '../functions/encrypt_decrypt.dart';
+
+class TokenController extends GetxController {
+  bool isloading = false;
+
+  Future addToken() async {
+    String? basicAuthCredentials =
+        await storage.read(key: BoxName.basicAuthCredentials);
+    isloading = true;
+    update();
+    var res = await http.post(
+      Uri.parse(AppLink.addTokens),
+      headers: {
+        'Authorization':
+            'Basic ${base64Encode(utf8.encode(basicAuthCredentials.toString()))}',
+      },
+      body: {
+        'token': (box.read(BoxName.tokenFCM.toString())),
+        'passengerID': box.read(BoxName.passengerID).toString()
+      },
+    );
+
+    isloading = false;
+    update();
+    var jsonToken = jsonDecode(res.body);
+    if (jsonToken['status'] == 'The token has been updated successfully.') {
+      Get.snackbar('token updated'.tr, '');
+    }
+  }
+}

siro_rider/lib/controller/auth/verify_email_controller.dart

@@ -0,0 +1,16 @@
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:siro_rider/constant/links.dart';
+import 'package:siro_rider/controller/functions/crud.dart';
+
+class VerifyEmailController extends GetxController {
+  TextEditingController verfyCode = TextEditingController();
+  @override
+  void onInit() async {
+    super.onInit();
+  }
+
+  sendverfications() async {
+    await CRUD().post(link: AppLink.sendVerifyEmail);
+  }
+}