Untitled

import 'dart:convert';
import 'dart:io';
import 'dart:math';
import 'dart:developer' as dev;
import 'package:dio/dio.dart' as mPart;
import 'package:dio/dio.dart';
import 'package:get/get.dart';
import 'package:get_storage/get_storage.dart';
import 'package:iketfaa_delivery/App/Common/Backend/firebase_crud.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/AppUser.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/BusinessRegDto.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/CityItem.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/ForgetPasswordDTOo.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/ForgetPasswordDto.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/RecommendedService.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/UserFirebase.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/address.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/document_dto.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/myfatoorah_banks.dart';
import 'package:iketfaa_delivery/App/Common/Models/Main/reset_password_dto.dart';
import 'package:iketfaa_delivery/App/Common/Models/RequestsParameters/AddSupplierParam.dart';
import 'package:iketfaa_delivery/App/Common/Models/RequestsParameters/EditSupplierBankInfoAddedParam.dart';
import 'package:iketfaa_delivery/App/Common/Models/RequestsParameters/EditSupplierCodeParam.dart';
import 'package:iketfaa_delivery/App/Common/Models/RequestsParameters/LoginParam.dart';
import 'package:iketfaa_delivery/App/Common/Models/RequestsParameters/UploadSupplierDocParam.dart';
import 'package:iketfaa_delivery/App/Common/Models/personel_register_model.dart';
import 'package:iketfaa_delivery/App/Common/Modules/Dashboard/binding/dashboard_binding.dart';
import 'package:iketfaa_delivery/App/Common/Modules/Dashboard/view/dashboard_view.dart';
import 'package:iketfaa_delivery/App/Common/Modules/OTP/binding/otp_binding.dart';
import 'package:iketfaa_delivery/App/Common/Modules/OTP/view/otp_view.dart';
import 'package:iketfaa_delivery/App/Common/Modules/SetPassword/binding/set_password_binding.dart';
import 'package:iketfaa_delivery/App/Common/Modules/SetPassword/view/set_password_view.dart';
import 'package:iketfaa_delivery/App/Common/Modules/SignUp/controller/signup_controller.dart';
import 'package:iketfaa_delivery/App/Common/Modules/Splash/view/start_page.dart';
import 'package:iketfaa_delivery/App/Common/Services/AuthenticationService/Core/manager.dart';
import 'package:iketfaa_delivery/App/Common/Successful/view/successful_view.dart';
import 'package:iketfaa_delivery/App/Common/Utilities/Constants/Strings/General.dart';
import 'package:iketfaa_delivery/App/Common/Utilities/Constants/UI.dart';
import 'package:iketfaa_delivery/App/Common/Utilities/Methods/tools.dart';
import 'package:iketfaa_delivery/App/Common/Widgets/SuccessfullPage.dart';
import 'package:iketfaa_delivery/App/Delivery/Models/Main/RequestParameter/CarModelItems.dart';
import 'package:iketfaa_delivery/App/Delivery/Models/Main/RequestParameter/CarTypesItems.dart';
import 'package:iketfaa_delivery/App/Delivery/Models/Main/RequestParameter/VehicleTypesItems.dart';
import 'package:iketfaa_delivery/App/Delivery/Models/Main/UserDeliveryCarDetails.dart';

import '../Models/Main/address_book_dto.dart';
import '../Models/Main/document_dto.dart';
import '../Models/Main/myfatoorah_banks.dart';
import '../Utilities/Constants/UI.dart';

class Api {
  static final Dio httpClient = Dio();
  static final String baseUrl = BASE_URL;
  static final String localBaseUrl = LOCALE_BASE_URL;
  static final GetStorage storage = GetStorage();
  static final CommonTools commonTools = CommonTools();
  final FirebaseCRUD firebaseCRUD = new FirebaseCRUD();
  static final String baseUrlMyFatoorah = 'https://api.myfatoorah.com/v2/';
  static final String myFatoorahAPItoken = MY_FATOORAH_TOKEN;

  Future setPassword(ResetPasswordDTO param, String id) async {
    final AuthenticationManager authManager = Get.find();
    await httpClient
        .post(
      baseUrl + 'Account/SetPassword',
      data: param.toJson(),
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Accept-Language': '${Get.locale!.languageCode}',
        },
      ),
    )
        .then((value) async {
      if (value.statusCode == 200) {
        authManager.logOut();
        Get.back();
        Get.offAll(
          () => SuccessfulView(
            content: 'successRegisterMess',
            duration: 4,
            function: () {
              Get.offAll(() => SignInStartView());

              // Get.offAll(() => SignInView(), binding: SignInBinding());
            },
          ),
        );

        // authManager.commonTools.showSuccessSnackBar('successRegisterMess');
      }
    }).catchError((e) {
      Get.back();

      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    });
  }

  Future<void> verifyOtp(String code, String target) async {
    final AuthenticationManager authManager = Get.find();
    await httpClient
        .post(
      baseUrl + 'Otp/VerifyOtp',
      data: {
        'appUserId': authManager.appUser.value.id,
        'code': code,
      },
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Accept-Language': '${Get.locale!.languageCode}',
        },
      ),
    )
        .then((response) {
      if (response.statusCode == 200) {
        if (target == 'ResetPassword') {
          Get.back();
          Get.offAll(() => SetPasswordView(), binding: SetPasswordBinding());
          authManager.commonTools.showSuccessSnackBar('verifiedSuccess');
        }
      }
    }).catchError((e) {
      Get.back();

      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'notCorrectOtp'
          : 'notCorrectOtp');
    });
  }

  Future<bool> userDeliveryCarDetails(
      UserDeliveryCarDetails userDeliveryCarDetails) async {
    final AuthenticationManager authManager = Get.find();
    // GetStorage box = GetStorage();
    bool result = false;
    await httpClient
        .post(
      baseUrl + 'Iktifaa/UserDeliveryCarDetails/Add',
      data: userDeliveryCarDetails.toJson(),
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Authorization': authManager.getToken(),
          'Accept-Language': '${Get.locale!.languageCode}',
        },
      ),
    )
        .then((response) {
      print(response.data);
      if (response.statusCode == 200) {
        result = true;
        //  box.write('delivery', 'delivery');
      }
    }).catchError((e) {
      Get.back();
      print(e);
      authManager.commonTools.showFailedSnackBar(
          e.response!.data[0]['errorMessage'] ?? 'notCorrect');
    });

    return result;
  }

  Future<void> personalReg(RegisterPersonalDto param) async {
    final AuthenticationManager authManager = Get.find();
    final SignUpController signUpController = Get.find();
    try {
      await httpClient
          .post(
        baseUrl + 'Iktifaa/Registration/RegisterRequesterIndividual',
        data: param.toJson(),
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((resoponse) async {
        if (resoponse.statusCode == 200) {
          print(resoponse.data);
          authManager.login(resoponse.data);

          await getUserDataByToken();
          Get.back();
          Get.offAll(() => OtpView(),
              binding: OtpBinding(), arguments: ['ResetPassword']);
          signUpController.clearPersonalTextField();
          commonTools.showSuccessSnackBar('successRegisterMess');
        }
      });
    } on DioError catch (e) {
      Get.back();
      Get.log('Status Code ${e.response!.statusCode} message ${e.response}');
      commonTools.showFailedSnackBar(
          e.response!.data[0]['errorMessage'] ?? 'failedRegisterMess');
    }
  }

  Future<List<RecommendedService>> getAllRecommendedServices() async {
    final AuthenticationManager authenticationManager = Get.find();
    List<RecommendedService> items = [];

    try {
      var response =
          await httpClient.get(baseUrl + 'RecommendedServices/GetAll',
              options: Options(headers: {
                'accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': authenticationManager.getToken(),
                'Accept-Language': '${Get.locale!.languageCode}',
              }));
      if (response.statusCode == 200) {
        items = List<RecommendedService>.from(json
            .decode(json.encode(response.data['data']['items']))
            .map((x) => RecommendedService.fromJson(x)));
      }
    } on DioError {
      // commonTools.showFailedSnackBar(e.message);
    }

    return items;
  }

  Future<void> providerLogin(LoginParam param) async {
    AuthenticationManager authManager = Get.find();

    await httpClient
        .post(
      baseUrl + 'Account/Login',
      data: param.toMap(),
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Accept-Language': '${Get.locale!.languageCode}',
        },
      ),
    )
        .then((response) async {
      if (response.statusCode == 200) {
        if (response.data['appUser'] != null) {
          authManager.appUser.value =
              AppUser.fromJson(response.data['appUser']);
          UserFirebase? userData =
              await authManager.firebaseCRUD.getCurrentUserDataByIDWithAdd();

          if (userData!.docID != null) {
            Get.back();

            if (response.data['token'] != null) {
              authManager.appUser.value.userFirebase = userData;
              storage.write('appUserId', authManager.appUser.value.id);
              authManager.login(response.data['token']);
              authManager.isLogged.value = true;
              Get.offAll(() => DashboardView(),
                  binding: DashboardBinding(), arguments: ['login']);
            }
          } else {
            authManager.appUser.value = AppUser();
            Get.back();
            commonTools.showFailedSnackBar('error login');
          }
        }
      } else {
        Get.back();
        commonTools.showFailedSnackBar('error login');
      }
    }).catchError((e) {
      Get.back();

      commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'error login'
          : 'error login');
    });
  }

  Future<void> getUserDataByToken() async {
    AuthenticationManager authManager = Get.find();

    print('get data');

    try {
      await httpClient.get(
        baseUrl + 'Account/GetUserDataByToken',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
        queryParameters: {
          'token': authManager.getToken(),
        },
      ).then((response) {
        if (response.statusCode == 200) {
          dev.log(response.data.toString());
          authManager.appUser.value = AppUser.fromJson(response.data);
        }
      });
    } on DioError catch (e) {
      print(e);
    }
  }

  Future<bool> addSupplier(AddSupplierParam param, String id) async {
    bool result = false;

    try {
      await httpClient
          .post(
        baseUrlMyFatoorah + 'CreateSupplier',
        data: param.toJson(),
        options: Options(
          sendTimeout: 6 * 1000,
          receiveTimeout: 6 * 1000,
          receiveDataWhenStatusError: true,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': 'Bearer $myFatoorahAPItoken',
          },
        ),
      )
          .then((value) async {
        if (value.statusCode == 200) {
          print('1');
          if (value.data['Data']['SupplierCode'] != null) {
            print('2');

            result = await updateSupplierCodeBankInfoAdded(
                true, value.data['Data']['SupplierCode']);
            if (result) {
              print('3');

              firebaseCRUD.addSupplierToFirebase(
                  param, id, value.data['Data']['SupplierCode']);
            }
          } else {
            print('4');

            Get.back();
            commonTools.showFailedSnackBar('Please try again in few seconds');

            return result;
          }
        } else {
          print('5');

          Get.back();
          commonTools.showFailedSnackBar('Please try again in few seconds');
          return result;
        }
      });
    } on DioError catch (e) {
      print('6');

      Get.back();

      if (e.response.toString().contains('Invalid Iban!')) {
        commonTools.showFailedSnackBar('enterValidIban');
      }
      return result;
    }
    print('7');

    return result;
  }

  Future editUserProfileData(
      {String? email, String? mobileNumber, String? provider}) async {
    AuthenticationManager authManager = Get.find();
    commonTools.showLoading();

    // add roles list to parameter
    try {
      var response = await httpClient.put(
        baseUrl + 'Account/EditUserProfileData/${authManager.appUser.value.id}',
        data: {
          'MobileNumber': mobileNumber,
          'EMail': email,
          'Roles': '$provider'
        },
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': authManager.getToken(),
          },
        ),
      );
      if (response.statusCode == 200) {
        Get.back();
        Get.back();
        authManager.commonTools
            .showSuccessSnackBar('You have been registered successfully');
      }
    } on DioError catch (e) {
      print(e.message);
      Get.back();
      authManager.commonTools.showSuccessSnackBar(e.message);
    }
  }

  Future<bool> updateSupplierCodeBankInfoAdded(bool supplier, int? code) async {
    AuthenticationManager authManager = Get.find();
    var data;

    if (supplier)
      data = EditSupplierCodeParam(supplierCode: code!);
    else
      data = EditSupplierBankInfoAddedParam(bankInfoAdded: true);

    try {
      var response = await httpClient.put(
        baseUrl +
            'Account/EditProviderProfileData/${authManager.appUser.value.id}',
        data: data.toJson(),
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': authManager.getToken(),
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      );
      if (response.statusCode == 200) {
        supplier
            ? authManager.appUser.value.provider!.supplierCode = code
            : authManager.appUser.value.provider!.bankInfoAdded = true;
        return true;
      }
    } on DioError catch (e) {
      print(e);
      return false;
    }

    return false;
  }

  Future<bool> uploadSupllierDocs(
      UploadSupplierDocParam doc, int supplierCode) async {
    bool result = false;

    mPart.FormData formData = mPart.FormData.fromMap({
      'FileUpload': await mPart.MultipartFile.fromFile(doc.filePath,
          filename: doc.fileName),
      'FileType': doc.fileType,
      'SupplierCode': supplierCode
    });

    try {
      await httpClient
          .put(
        baseUrlMyFatoorah + 'UploadSupplierDocument',
        data: formData,
        options: Options(
          sendTimeout: 6 * 1000,
          receiveTimeout: 6 * 1000,
          receiveDataWhenStatusError: true,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': 'Bearer $myFatoorahAPItoken',
          },
        ),
      )
          .then((value) async {
        if (value.statusCode == 200) {
          if (doc.fileType == 1) {
            result = await updateSupplierCodeBankInfoAdded(false, supplierCode);
          } else {
            result = true;
            Get.back();
          }
        } else {
          Get.back();
        }
      });
    } on DioError catch (e) {
      print(e.message);
      Get.back();
    }

    return result;
  }

  Future forgetPass(ForgetPasswordDto param) async {
    commonTools.showLoading();
    var response = await httpClient
        .post(
      baseUrl + 'Account/ForgetPassword',
      data: param.toJson(),
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Accept-Language': '${Get.locale!.languageCode}',
        },
      ),
    )
        .catchError((e) {
      print(e);
      Get.back();
      commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'email not found'
          : 'email not found');
    });
    if (response.statusCode == 200) {
      GetStorage box = GetStorage();
      print('please wait for the new password...');
      print('the status is = ' + '${response.statusCode}');
      final validMap =
          json.decode(json.encode(response.data)) as Map<String, dynamic>;
      ForgetPasswordDTO resp = ForgetPasswordDTO.fromJson(validMap);
      box.write('newToken', resp.data);
      print('new token =${resp.data} ');
      Get.back();
      return resp;
    }
  }

  Future<String> resetPassword(ResetPasswordDTO param, context) async {
    commonTools.showLoading();
    try {
      await httpClient
          .put(
        baseUrl + 'Account/ResetPassword',
        data: param.toJson(),
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((value) {
        if (value.statusCode == 200) {
          commonTools.unFocusKeyboard(context);
          Get.back();
          Get.to(() => SuccessfullPage(
                content: 'Password changed successfully'.tr,
                function: () {
                  Get.offAll(() => SignInStartView());
                },
              ));
          commonTools.showSuccessSnackBar('Password changed successfully');
          return 'Success';
        }
      });
    } on DioError catch (e) {
      Get.back();
      print(e.message);
      commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }

    return 'failed';
  }

  Future businessReg(BusinessRegDto param) async {
    final AuthenticationManager authManager = Get.find();
    print(param.toJson().toString());

    try {
      await httpClient
          .post(
        baseUrl + 'Iktifaa/Registration/RegisterBuisness',
        data: param.toJson(),
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((resoponse) async {
        if (resoponse.statusCode == 200) {
          authManager.login(resoponse.data);

          await getUserDataByToken();
        }
      });
    } on DioError catch (e) {
      Get.back();
      authManager.logOut();
      commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'failedRegisterMess'
          : 'failedRegisterMess');
    }
  }

  Future<String> requesterAddAddressBook(AddressBookDto param) async {
    GetStorage box = GetStorage();
    try {
      var response = await httpClient
          .post(
        baseUrl + 'Iktifaa/RequesterAddressBooks/Add',
        data: param.toJson(),
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': box.read('token'),
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((value) {
        if (value.statusCode == 200) {
          print(value.statusCode);
          Get.showSnackbar(UI.SuccessSnackBar(
            title: 'Success'.tr,
            message: 'Address information completed',
          ));
        }
      });
      return response.data;
    } on DioError catch (e) {
      Get.log(
          'Status Code ${e.response!.statusCode} message ${e.response!.statusMessage}');
      Get.showSnackbar(
        UI.ErrorSnackBar(
            title: '',
            message: 'There are errors in some fields please correct them!'.tr),
      );
      return 'error';
    }
  }

  Future<void> addDocument(
      {IktifaaRegDocsDTO? param,
      List<File>? listFiles,
      Function? function}) async {
    final AuthenticationManager authManager = Get.find();

    mPart.FormData form = mPart.FormData.fromMap({
      'documents': jsonEncode(param!.documents!.map((e) => e.toJson()).toList())
    });
    for (var file in listFiles!) {
      form.files.add(
        MapEntry(
          '[files]',
          mPart.MultipartFile.fromBytes(
            file.readAsBytesSync(),
            filename: '${DateTime.now().toUtc()}${Random().nextInt(1000)}.jpg',
          ),
        ),
      );
    }
    try {
      await httpClient
          .post(
        baseUrl + 'Iktifaa/UserRegistrationDocuments/Add',
        data: form,
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': authManager.getToken(),
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((response) {
        if (response.statusCode == 200) {
          Get.back();
          function!();
          commonTools.showSuccessSnackBar('successRegisterMess');
        }
      });
    } on DioError catch (e) {
      print(e.response!.data);
      Get.back();
      commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'failedRegisterMess'
          : 'failedRegisterMess');
    }
  }

  Future<List<CarTypesItems>> getAllCarTypes() async {
    final AuthenticationManager authManager = Get.find();
    List<CarTypesItems> carTypesItems = [];
    try {
      await httpClient
          .get(baseUrl + 'LookupCarTypes/GetAll',
              options: Options(headers: {
                'accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': authManager.getToken(),
                'Accept-Language': '${Get.locale!.languageCode}',
              }))
          .then((response) {
        if (response.statusCode == 200) {
          carTypesItems = List<CarTypesItems>.from(json
              .decode(json.encode(response.data['data']['items']))
              .map((x) => CarTypesItems.fromJson(x)));
          return CarTypesItems;
        }
      });
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }
    return carTypesItems;
  }

  Future<List<VehicleTypesItems>> getAllVehicleTypes() async {
    final AuthenticationManager authManager = Get.find();
    List<VehicleTypesItems> vehicleTypesItems = [];
    try {
      var response = await httpClient.get(baseUrl + 'LookupVehicleTypes/GetAll',
          options: Options(headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': authManager.getToken(),
            'Accept-Language': '${Get.locale!.languageCode}',
          }));
      if (response.statusCode == 200) {
        vehicleTypesItems = List<VehicleTypesItems>.from(json
            .decode(json.encode(response.data['data']['items']))
            .map((x) => VehicleTypesItems.fromJson(x)));
        return vehicleTypesItems;
      }
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }
    return vehicleTypesItems;
  }

  Future<List<CarModelItems>> getAllCarModels(String? carTypeID) async {
    List<CarModelItems> carsModelsList = [];
    final AuthenticationManager authManager = Get.find();
    try {
      var response = await httpClient.get(baseUrl + 'LookupCarModels/GetAll',
          queryParameters: {'searchCriteriaModel.carTypeId': carTypeID},
          options: Options(headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Accept-Language': '${Get.locale!.languageCode}',
          }));
      if (response.statusCode == 200) {
        carsModelsList = List<CarModelItems>.from(json
            .decode(json.encode(response.data['data']['items']))
            .map((x) => CarModelItems.fromJson(x)));
        return carsModelsList;
      }
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }
    return carsModelsList;
  }

  Future<List<CityItem>> getAllCities() async {
    final AuthenticationManager authManager = Get.find();
    List<CityItem> list = [];
    try {
      await httpClient
          .get(baseUrl + 'City/GetAll',
              options: Options(headers: {
                'accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': authManager.getToken(),
                'Accept-Language': '${Get.locale!.languageCode}',
              }))
          .then((response) {
        if (response.statusCode == 200) {
          list = List<CityItem>.from(json
              .decode(json.encode(response.data['data']['items']))
              .map((x) => CityItem.fromJson(x)));
        }
      });
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }
    return list;
  }

  Future<List<MyFatoorahBank>> getBanksList() async {
    List<MyFatoorahBank> bankList = <MyFatoorahBank>[];
    try {
      await httpClient
          .get(
        baseUrlMyFatoorah + 'GetBanks',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': 'Bearer $myFatoorahAPItoken',
          },
        ),
      )
          .then((value) async {
        bankList = List<MyFatoorahBank>.from(json
            .decode(json.encode(value.data))
            .map((x) => MyFatoorahBank.fromJson(x)));
        return bankList;
      });
    } on DioError catch (e) {
      Get.log('Status Code ${e.response!.statusCode} message ${e.response}');
    }
    return bankList;
  }

  Future resendOTP() async {
    final AuthenticationManager authManager = Get.find();

    try {
      await httpClient
          .post(
        baseUrl + 'Otp/ReSendOtp',
        data: {
          'token': authManager.getToken(),
        },
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': authManager.getToken(),
            'Accept-Language': '${Get.locale!.languageCode}',
          },
        ),
      )
          .then((response) async {
        if (response.statusCode == 200) {
          authManager.commonTools.showSuccessSnackBar('otpSentSuccessfully');
        }
      });
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'otpSentFailed'
          : 'otpSentFailed');
    }
  }

  Future<List<Address>> getAllAddresses() async {
    final AuthenticationManager authManager = Get.find();
    List<Address> list = [];

    try {
      await httpClient
          .get(baseUrl + 'Iktifaa/RequesterAddressBooks/GetAll',
              queryParameters: {
                'searchCriteriaModel.requesterId': authManager.appUser.value.id,
              },
              options: Options(headers: {
                'accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': authManager.getToken(),
                'Accept-Language': '${Get.locale!.languageCode}',
              }))
          .then((response) {
        if (response.statusCode == 200) {
          list = List<Address>.from(json
              .decode(json.encode(response.data['data']['items']))
              .map((x) => Address.fromJson(x)));
        }
      });
    } on DioError catch (e) {
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }

    return list;
  }

  Future<bool> editProfilePicture(mPart.MultipartFile file) async {
    final AuthenticationManager authManager = Get.find();
    authManager.commonTools.showLoading();
    bool result = false;

    mPart.FormData form = mPart.FormData.fromMap({
      'id': authManager.appUser.value.id,
    });
    form.files.add(MapEntry('file', file));

    try {
      await httpClient.post(
        baseUrl + 'Account/ChangeProfilePicture',
        data: form,
        onSendProgress: (a, b) {
          print('onSendProgress $a $b');
        },
        onReceiveProgress: (a, b) {
          print('onReceiveProgress $a $b');
        },
        options: Options(
          headers: {
            'accept': 'multipart/form-data',
            'Content-Type': 'multipart/form-data',
            'Authorization': authManager.getToken()
          },
        ),
      ).then((response) {
        if (response.statusCode == 200) {
          if (response.data['succeeded'] == true) {
            print(response.data);
            result = true;
            authManager.appUser.update((val) {
              val!.profilePictureUrl = response.data['data'];
            });
          }
        }
        Get.back();
      });
    } on DioError catch (e) {
      Get.back();
      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }

    return result;
  }

  Future<bool> editCoverPicture(mPart.MultipartFile file) async {
    final AuthenticationManager authManager = Get.find();
    authManager.commonTools.showLoading();
    bool result = false;

    mPart.FormData form = mPart.FormData.fromMap({
      'id': authManager.appUser.value.id,
    });
    form.files.add(MapEntry('file', file));

    try {
      await httpClient.post(
        baseUrl + 'Account/ChangeProfileCoverPhoto',
        data: form,
        onSendProgress: (a, b) {
          print('onSendProgress $a $b');
        },
        onReceiveProgress: (a, b) {
          print('onReceiveProgress $a $b');
        },
        options: Options(
          headers: {
            'accept': 'multipart/form-data',
            'Content-Type': 'multipart/form-data',
            'Authorization': authManager.getToken()
          },
        ),
      ).then((response) {
        if (response.statusCode == 200) {
          if (response.data['succeeded'] == true) {
            print(response.data);
            result = true;

            authManager.appUser.update((val) {
              val!.profileCoverPhotoUrl = response.data['data'];
            });
          }
        }
        Get.back();
      });
    } on DioError catch (e) {
      Get.back();

      authManager.commonTools.showFailedSnackBar(e.response!.data != null
          ? e.response!.data[0] != null
              ? e.response!.data[0]['errorMessage']
              : 'errorMessage'
          : 'errorMessage');
    }
    return result;
  }
}