From aa1b9e899aba4fc333887da19aedf49956133b6e Mon Sep 17 00:00:00 2001 From: "mr.mojtaba" Date: Mon, 11 Aug 2025 12:56:26 +0330 Subject: [PATCH] feat : cashing data in local storage and send it --- lib/main.dart | 2 +- packages/core/devtools_options.yaml | 3 + .../data/services/token_storage_service.dart | 2 +- .../core/lib/utils/local/local_utils.dart | 10 +- packages/inspection/devtools_options.yaml | 3 + packages/livestock/devtools_options.yaml | 3 + .../livestock/livestock_remote_imp.dart | 4 +- .../lib/data/model/local/live_tmp/car.dart | 39 ++++ .../lib/data/model/local/live_tmp/car.g.dart | 41 ++++ .../local/live_tmp/livestock_local_model.dart | 97 ++++++++ .../live_tmp/livestock_local_model.g.dart | 217 ++++++++++++++++++ .../service/live_stock_storage_service.dart | 40 ++++ packages/livestock/lib/data/utils/mapper.dart | 106 +++++++++ packages/livestock/lib/hive_registrar.g.dart | 29 +++ .../lib/injection/live_stock_di.dart | 8 +- .../page/request_tagging/logic.dart | 63 ++--- 16 files changed, 635 insertions(+), 32 deletions(-) create mode 100644 packages/core/devtools_options.yaml create mode 100644 packages/inspection/devtools_options.yaml create mode 100644 packages/livestock/devtools_options.yaml create mode 100644 packages/livestock/lib/data/model/local/live_tmp/car.dart create mode 100644 packages/livestock/lib/data/model/local/live_tmp/car.g.dart create mode 100644 packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.dart create mode 100644 packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.g.dart create mode 100644 packages/livestock/lib/data/service/live_stock_storage_service.dart create mode 100644 packages/livestock/lib/data/utils/mapper.dart create mode 100644 packages/livestock/lib/hive_registrar.g.dart diff --git a/lib/main.dart b/lib/main.dart index 09db360..7b63ac2 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -8,7 +8,7 @@ import 'presentation/routes/auth_route_resolver_impl.dart'; Future main() async { WidgetsFlutterBinding.ensureInitialized(); - + await Hive.initFlutter(); await setupPreInjection(); Get.put(TokenStorageService()); await Get.find().init(); diff --git a/packages/core/devtools_options.yaml b/packages/core/devtools_options.yaml new file mode 100644 index 0000000..fa0b357 --- /dev/null +++ b/packages/core/devtools_options.yaml @@ -0,0 +1,3 @@ +description: This file stores settings for Dart & Flutter DevTools. +documentation: https://docs.flutter.dev/tools/devtools/extensions#configure-extension-enablement-states +extensions: diff --git a/packages/core/lib/data/services/token_storage_service.dart b/packages/core/lib/data/services/token_storage_service.dart index ab551c9..6d0f3c3 100644 --- a/packages/core/lib/data/services/token_storage_service.dart +++ b/packages/core/lib/data/services/token_storage_service.dart @@ -21,7 +21,7 @@ class TokenStorageService extends GetxService { Rxn appModule = Rxn(null); Future init() async { - await Hive.initFlutter(); + Hive.registerAdapters(); final String? encryptedKey = await _secureStorage.read(key: 'hive_enc_key'); diff --git a/packages/core/lib/utils/local/local_utils.dart b/packages/core/lib/utils/local/local_utils.dart index 04f3e5d..d6cf456 100644 --- a/packages/core/lib/utils/local/local_utils.dart +++ b/packages/core/lib/utils/local/local_utils.dart @@ -4,4 +4,12 @@ const int authModuleTypeId = 1; //chicken const int chickenWidelyUsedLocalModelTypeId = 2; -const int chickenWidelyUsedLocalItemTypeId = 3; \ No newline at end of file +const int chickenWidelyUsedLocalItemTypeId = 3; + +//liveStock + +const int liveStockDataLocalModelTypeId = 4; +const int liveStockDataRancherLocalModelTypeId = 5; +const int liveStockDataHerdLocalModelTypeId = 6; +const int liveStockDataLocationLocalModelTypeId = 7; +const int liveStockDataLivestockLocalModelTypeId = 8; \ No newline at end of file diff --git a/packages/inspection/devtools_options.yaml b/packages/inspection/devtools_options.yaml new file mode 100644 index 0000000..fa0b357 --- /dev/null +++ b/packages/inspection/devtools_options.yaml @@ -0,0 +1,3 @@ +description: This file stores settings for Dart & Flutter DevTools. +documentation: https://docs.flutter.dev/tools/devtools/extensions#configure-extension-enablement-states +extensions: diff --git a/packages/livestock/devtools_options.yaml b/packages/livestock/devtools_options.yaml new file mode 100644 index 0000000..fa0b357 --- /dev/null +++ b/packages/livestock/devtools_options.yaml @@ -0,0 +1,3 @@ +description: This file stores settings for Dart & Flutter DevTools. +documentation: https://docs.flutter.dev/tools/devtools/extensions#configure-extension-enablement-states +extensions: diff --git a/packages/livestock/lib/data/data_source/remote/livestock/livestock_remote_imp.dart b/packages/livestock/lib/data/data_source/remote/livestock/livestock_remote_imp.dart index 642c3ed..f6cfb01 100644 --- a/packages/livestock/lib/data/data_source/remote/livestock/livestock_remote_imp.dart +++ b/packages/livestock/lib/data/data_source/remote/livestock/livestock_remote_imp.dart @@ -33,8 +33,8 @@ class LivestockRemoteDataSourceImp implements LivestockRemoteDataSource { try { Dio dio = Dio(); dio.interceptors.add(PrettyDioLogger( - requestBody: true, - responseBody: true, + requestBody: false, + responseBody: false, requestHeader: true, responseHeader: true, error: true, diff --git a/packages/livestock/lib/data/model/local/live_tmp/car.dart b/packages/livestock/lib/data/model/local/live_tmp/car.dart new file mode 100644 index 0000000..19bb320 --- /dev/null +++ b/packages/livestock/lib/data/model/local/live_tmp/car.dart @@ -0,0 +1,39 @@ +import 'package:rasadyar_core/core.dart'; + + +part 'car.g.dart'; + + +@HiveType(typeId: 50) +class CarsLocal extends HiveObject { + @HiveField(0) + String? name; + + @HiveField(1) + String? price; + + CarsLocal({this.name, this.price}); + + factory CarsLocal.fromJson(Map json) { + return CarsLocal(name: json['name'] as String?, price: json['price'] as String?); + } + + Map toJson() { + return {'name': name, 'price': price}; + } +} + +class Cars { + String? name; + String? price; + + Cars({this.name, this.price}); + + factory Cars.fromJson(Map json) { + return Cars(name: json['name'] as String?, price: json['price'] as String?); + } + + Map toJson() { + return {'name': name, 'price': price}; + } +} diff --git a/packages/livestock/lib/data/model/local/live_tmp/car.g.dart b/packages/livestock/lib/data/model/local/live_tmp/car.g.dart new file mode 100644 index 0000000..77d0985 --- /dev/null +++ b/packages/livestock/lib/data/model/local/live_tmp/car.g.dart @@ -0,0 +1,41 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'car.dart'; + +// ************************************************************************** +// TypeAdapterGenerator +// ************************************************************************** + +class CarsLocalAdapter extends TypeAdapter { + @override + final typeId = 50; + + @override + CarsLocal read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return CarsLocal(name: fields[0] as String?, price: fields[1] as String?); + } + + @override + void write(BinaryWriter writer, CarsLocal obj) { + writer + ..writeByte(2) + ..writeByte(0) + ..write(obj.name) + ..writeByte(1) + ..write(obj.price); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is CarsLocalAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} diff --git a/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.dart b/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.dart new file mode 100644 index 0000000..a42cfb6 --- /dev/null +++ b/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.dart @@ -0,0 +1,97 @@ +import 'package:rasadyar_core/core.dart'; + + +part 'livestock_local_model.g.dart'; + +@HiveType(typeId: liveStockDataLocalModelTypeId) + class LivestockLocalModel extends HiveObject { + + + @HiveField(0) + RancherLocal? rancher; + + @HiveField(1) + HerdLocal? herd; + + @HiveField(2) + List? livestock; + +} + + + +@HiveType(typeId: liveStockDataRancherLocalModelTypeId) + class RancherLocal extends HiveObject { + + @HiveField(0) + String? name; + + @HiveField(1) + String? phone; + + @HiveField(2) + String? image; +} + + +@HiveType(typeId: liveStockDataHerdLocalModelTypeId) +class HerdLocal extends HiveObject{ + + @HiveField(0) + LocationLocal? location; + + @HiveField(1) + String? address; + + @HiveField(2) + String? image; + + +} + + +@HiveType(typeId: liveStockDataLocationLocalModelTypeId) +class LocationLocal extends HiveObject { + + @HiveField(0) + double? lat; + + @HiveField(1) + double? lng; + +} + + +@HiveType(typeId: liveStockDataLivestockLocalModelTypeId) +class LivestockLocal extends HiveObject { + + + @HiveField(0) + String? species; + + @HiveField(1) + String? breed; + + @HiveField(2) + String? dateOfBirth; + + @HiveField(3) + String? sex; + + @HiveField(4) + String? motherTag; + + @HiveField(5) + String? fatherTag; + + @HiveField(6) + String? tagNumber; + + @HiveField(7) + String? tagType; + + @HiveField(8) + String? image; + + +} diff --git a/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.g.dart b/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.g.dart new file mode 100644 index 0000000..921da9a --- /dev/null +++ b/packages/livestock/lib/data/model/local/live_tmp/livestock_local_model.g.dart @@ -0,0 +1,217 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'livestock_local_model.dart'; + +// ************************************************************************** +// TypeAdapterGenerator +// ************************************************************************** + +class LivestockLocalModelAdapter extends TypeAdapter { + @override + final typeId = 4; + + @override + LivestockLocalModel read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return LivestockLocalModel() + ..rancher = fields[0] as RancherLocal? + ..herd = fields[1] as HerdLocal? + ..livestock = (fields[2] as List?)?.cast(); + } + + @override + void write(BinaryWriter writer, LivestockLocalModel obj) { + writer + ..writeByte(3) + ..writeByte(0) + ..write(obj.rancher) + ..writeByte(1) + ..write(obj.herd) + ..writeByte(2) + ..write(obj.livestock); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is LivestockLocalModelAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} + +class RancherLocalAdapter extends TypeAdapter { + @override + final typeId = 5; + + @override + RancherLocal read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return RancherLocal() + ..name = fields[0] as String? + ..phone = fields[1] as String? + ..image = fields[2] as String?; + } + + @override + void write(BinaryWriter writer, RancherLocal obj) { + writer + ..writeByte(3) + ..writeByte(0) + ..write(obj.name) + ..writeByte(1) + ..write(obj.phone) + ..writeByte(2) + ..write(obj.image); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is RancherLocalAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} + +class HerdLocalAdapter extends TypeAdapter { + @override + final typeId = 6; + + @override + HerdLocal read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return HerdLocal() + ..location = fields[0] as LocationLocal? + ..address = fields[1] as String? + ..image = fields[2] as String?; + } + + @override + void write(BinaryWriter writer, HerdLocal obj) { + writer + ..writeByte(3) + ..writeByte(0) + ..write(obj.location) + ..writeByte(1) + ..write(obj.address) + ..writeByte(2) + ..write(obj.image); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is HerdLocalAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} + +class LocationLocalAdapter extends TypeAdapter { + @override + final typeId = 7; + + @override + LocationLocal read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return LocationLocal() + ..lat = (fields[0] as num?)?.toDouble() + ..lng = (fields[1] as num?)?.toDouble(); + } + + @override + void write(BinaryWriter writer, LocationLocal obj) { + writer + ..writeByte(2) + ..writeByte(0) + ..write(obj.lat) + ..writeByte(1) + ..write(obj.lng); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is LocationLocalAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} + +class LivestockLocalAdapter extends TypeAdapter { + @override + final typeId = 8; + + @override + LivestockLocal read(BinaryReader reader) { + final numOfFields = reader.readByte(); + final fields = { + for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(), + }; + return LivestockLocal() + ..species = fields[0] as String? + ..breed = fields[1] as String? + ..dateOfBirth = fields[2] as String? + ..sex = fields[3] as String? + ..motherTag = fields[4] as String? + ..fatherTag = fields[5] as String? + ..tagNumber = fields[6] as String? + ..tagType = fields[7] as String? + ..image = fields[8] as String?; + } + + @override + void write(BinaryWriter writer, LivestockLocal obj) { + writer + ..writeByte(9) + ..writeByte(0) + ..write(obj.species) + ..writeByte(1) + ..write(obj.breed) + ..writeByte(2) + ..write(obj.dateOfBirth) + ..writeByte(3) + ..write(obj.sex) + ..writeByte(4) + ..write(obj.motherTag) + ..writeByte(5) + ..write(obj.fatherTag) + ..writeByte(6) + ..write(obj.tagNumber) + ..writeByte(7) + ..write(obj.tagType) + ..writeByte(8) + ..write(obj.image); + } + + @override + int get hashCode => typeId.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is LivestockLocalAdapter && + runtimeType == other.runtimeType && + typeId == other.typeId; +} diff --git a/packages/livestock/lib/data/service/live_stock_storage_service.dart b/packages/livestock/lib/data/service/live_stock_storage_service.dart new file mode 100644 index 0000000..1d3e60a --- /dev/null +++ b/packages/livestock/lib/data/service/live_stock_storage_service.dart @@ -0,0 +1,40 @@ +import 'package:rasadyar_core/core.dart'; +import 'package:rasadyar_livestock/data/model/local/live_tmp/car.dart'; +import 'package:rasadyar_livestock/data/model/local/live_tmp/livestock_local_model.dart'; +import 'package:rasadyar_livestock/data/model/response/live_tmp/livestock_model.dart'; +import 'package:rasadyar_livestock/data/utils/mapper.dart'; + +class LiveStockStorageService extends GetxService { + final String _liveStockBoxName = 'LiveStockBox'; + late IsolatedBox _LiveStockbox; + late IsolatedBox _carbox; + + @override + void onInit() { + super.onInit(); + wLog('LiveStockStorageService onInit'); + IsolatedHive.openBox(_liveStockBoxName).then((value) { + _LiveStockbox = value; + }); + } + + Future saveLiveStockData(LivestockData livestockData) async { + LivestockLocalModel tmp = livestockData.toLocal(); + await _LiveStockbox.add(tmp); + } + + Future saveBulkLiveStockData(Iterable livesList) async { + var tmp = livesList.map((e) => e.toLocal()).toList(); + await _LiveStockbox.addAll(tmp); + } + + Future> getLiveStockData() async { + var liveLocationList = await _LiveStockbox.values; + var res = liveLocationList.map((e) => e.toData()).toList(); + return res; + } + + Future deleteLiveBox() async { + return await _LiveStockbox.clear(); + } +} diff --git a/packages/livestock/lib/data/utils/mapper.dart b/packages/livestock/lib/data/utils/mapper.dart new file mode 100644 index 0000000..6a6a34a --- /dev/null +++ b/packages/livestock/lib/data/utils/mapper.dart @@ -0,0 +1,106 @@ +import '../model/local/live_tmp/livestock_local_model.dart'; +import '../model/response/live_tmp/livestock_model.dart'; + +// Extension for LivestockData to convert to LivestockLocalModel +extension LivestockDataX on LivestockData { + LivestockLocalModel toLocal() { + return LivestockLocalModel() + ..rancher = rancher?.toLocal() + ..herd = herd?.toLocal() + ..livestock = livestock?.map((e) => e.toLocal()).toList(); + } +} + +// Extension for LivestockLocalModel to convert to LivestockData +extension LivestockLocalModelX on LivestockLocalModel { + LivestockData toData() { + return LivestockData( + rancher: rancher?.toData(), + herd: herd?.toData(), + livestock: livestock?.map((e) => e.toData()).toList(), + ); + } +} + +// Extension for Rancher to convert to RancherLocal +extension RancherX on Rancher { + RancherLocal toLocal() { + return RancherLocal() + ..name = name + ..phone = phone + ..image = image; + } +} + +// Extension for RancherLocal to convert to Rancher +extension RancherLocalX on RancherLocal { + Rancher toData() { + return Rancher(name: name, phone: phone, image: image); + } +} + +// Extension for Herd to convert to HerdLocal +extension HerdX on Herd { + HerdLocal toLocal() { + return HerdLocal() + ..location = location?.toLocal() + ..address = address + ..image = image; + } +} + +// Extension for HerdLocal to convert to Herd +extension HerdLocalX on HerdLocal { + Herd toData() { + return Herd(location: location?.toData(), address: address, image: image); + } +} + +// Extension for Location to convert to LocationLocal +extension LocationX on Location { + LocationLocal toLocal() { + return LocationLocal() + ..lat = lat + ..lng = lng; + } +} + +// Extension for LocationLocal to convert to Location +extension LocationLocalX on LocationLocal { + Location toData() { + return Location(lat: lat, lng: lng); + } +} + +// Extension for Livestock to convert to LivestockLocal +extension LivestockX on Livestock { + LivestockLocal toLocal() { + return LivestockLocal() + ..species = species + ..breed = breed + ..dateOfBirth = dateOfBirth + ..sex = sex + ..motherTag = motherTag + ..fatherTag = fatherTag + ..tagNumber = tagNumber + ..tagType = tagType + ..image = image; + } +} + +// Extension for LivestockLocal to convert to Livestock +extension LivestockLocalX on LivestockLocal { + Livestock toData() { + return Livestock( + species: species, + breed: breed, + dateOfBirth: dateOfBirth, + sex: sex, + motherTag: motherTag, + fatherTag: fatherTag, + tagNumber: tagNumber, + tagType: tagType, + image: image, + ); + } +} diff --git a/packages/livestock/lib/hive_registrar.g.dart b/packages/livestock/lib/hive_registrar.g.dart new file mode 100644 index 0000000..715ff9e --- /dev/null +++ b/packages/livestock/lib/hive_registrar.g.dart @@ -0,0 +1,29 @@ +// Generated by Hive CE +// Do not modify +// Check in to version control + +import 'package:hive_ce/hive.dart'; +import 'package:rasadyar_livestock/data/model/local/live_tmp/car.dart'; +import 'package:rasadyar_livestock/data/model/local/live_tmp/livestock_local_model.dart'; + +extension HiveRegistrar on HiveInterface { + void registerAdapters() { + registerAdapter(CarsLocalAdapter()); + registerAdapter(HerdLocalAdapter()); + registerAdapter(LivestockLocalAdapter()); + registerAdapter(LivestockLocalModelAdapter()); + registerAdapter(LocationLocalAdapter()); + registerAdapter(RancherLocalAdapter()); + } +} + +extension IsolatedHiveRegistrar on IsolatedHiveInterface { + void registerAdapters() { + registerAdapter(CarsLocalAdapter()); + registerAdapter(HerdLocalAdapter()); + registerAdapter(LivestockLocalAdapter()); + registerAdapter(LivestockLocalModelAdapter()); + registerAdapter(LocationLocalAdapter()); + registerAdapter(RancherLocalAdapter()); + } +} diff --git a/packages/livestock/lib/injection/live_stock_di.dart b/packages/livestock/lib/injection/live_stock_di.dart index d374105..eb099c9 100644 --- a/packages/livestock/lib/injection/live_stock_di.dart +++ b/packages/livestock/lib/injection/live_stock_di.dart @@ -8,14 +8,20 @@ import 'package:rasadyar_livestock/data/repository/auth/auth_repository.dart'; import 'package:rasadyar_livestock/data/repository/auth/auth_repository_imp.dart'; import 'package:rasadyar_livestock/data/repository/livestock/livestock_repository.dart'; import 'package:rasadyar_livestock/data/repository/livestock/livestock_repository_imp.dart'; +import 'package:rasadyar_livestock/data/service/live_stock_storage_service.dart'; +import 'package:rasadyar_livestock/hive_registrar.g.dart'; import 'package:rasadyar_livestock/presentation/routes/app_pages.dart'; GetIt get diLiveStock => GetIt.instance; Future setupLiveStockDI() async { diLiveStock.registerSingleton(DioErrorHandler()); - + await IsolatedHive.initFlutter(); + IsolatedHive.registerAdapters(); + iLog("Sssssssssssssssssssss"); final tokenService = Get.find(); + Get.put(LiveStockStorageService()); + if (tokenService.baseurl.value == null) { await tokenService.saveBaseUrl('https://api.dam.rasadyar.net/'); diff --git a/packages/livestock/lib/presentation/page/request_tagging/logic.dart b/packages/livestock/lib/presentation/page/request_tagging/logic.dart index 245ae69..0625a2c 100644 --- a/packages/livestock/lib/presentation/page/request_tagging/logic.dart +++ b/packages/livestock/lib/presentation/page/request_tagging/logic.dart @@ -1,16 +1,18 @@ import 'dart:convert'; import 'dart:io'; import 'dart:math'; -import 'dart:typed_data'; +import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:rasadyar_core/core.dart'; import 'package:rasadyar_livestock/data/model/response/address/address.dart'; import 'package:rasadyar_livestock/data/model/response/live_tmp/livestock_model.dart'; import 'package:rasadyar_livestock/data/repository/livestock/livestock_repository.dart'; +import 'package:rasadyar_livestock/data/service/live_stock_storage_service.dart'; import 'package:rasadyar_livestock/injection/live_stock_di.dart'; class RequestTaggingLogic extends GetxController { + LiveStockStorageService liveStockStorageService = Get.find(); RxInt currentIndex = 0.obs; final int maxStep = 2; @@ -82,19 +84,17 @@ class RequestTaggingLogic extends GetxController { rancher.value = Rancher( name: 'حسن حسنی', phone: '09121234567', - image: - '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', + image: '/9j/4nd9KcTTcWUsuoF0cSwuZSjYX', ); herd.value = Herd( location: Location(lat: 35.825081, lng: 50.948177), address: 'استان البرز, بخش مرکزی کرج, کرج, منطقه ۵, دهقان ویلا, بلوار سرداران', - image: - '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', + image: '/9j/4QL6RXhpZgAATU0AKgAA', ); var s = List.generate( - 10000, + 10_000, (index) => Livestock( sex: index % 2 == 0 ? 'نر' : 'ماده', tagNumber: index.toString(), @@ -104,8 +104,7 @@ class RequestTaggingLogic extends GetxController { breed: index % 2 == 0 ? 'گوسفند ماده' : 'گاو ماده', tagType: index % 2 == 0 ? 'نوع 1' : 'نوع 2', dateOfBirth: "23/10/2023", - image: - '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', + image: '/9j/4QLmRXhpZgAATU', ), ); livestockList.addAll(s); @@ -282,36 +281,48 @@ class RequestTaggingLogic extends GetxController { } Future createTaggingLiveStock() async { - isLoading.value = true; + // isLoading.value = true; if (livestockList.isEmpty) { Get.snackbar('Error', 'Please fill all required fields'); return; } - var livestockBatch = []; + var batches = chunkedList( + livestockList, + 500, + ).map((e) => LivestockData(rancher: rancher.value, herd: herd.value, livestock: e)); - for (int i = 0; i < livestockList.length; i += 500) { - var tmp = livestockList.sublist(i, min(i + 500, livestockList.length)); + await liveStockStorageService.saveBulkLiveStockData(batches); - livestockBatch.add( - safeCall( - call: () => livestockRepository.createTaggingLiveStock( - data: LivestockData(livestock: tmp, herd: herd.value, rancher: rancher.value), - ), - onSuccess: (result) {}, - onError: (error, stackTrace) { - Get.snackbar( - 'Error', - 'Failed to create livestock tagging request: ${error.toString()}', - ); - }, - ), + var tmpData = await liveStockStorageService.getLiveStockData(); + + for (int i = 0; i < tmpData.length; i++) { + await safeCall( + call: () => livestockRepository.createTaggingLiveStock(data: tmpData[i]), + onSuccess: (result) async { + if (i == tmpData.length - 1) { + Get.snackbar('Success', 'All livestock tagged successfully'); + await liveStockStorageService.deleteLiveBox(); + var ss = await liveStockStorageService.getLiveStockData(); + iLog('tagged livestock: ${ss.length}'); + } + }, + onError: (error, stackTrace) {}, ); } - await Future.wait(livestockBatch); + isLoading.value = false; } + List> chunkedList(List list, int chunkSize) { + List> batches = []; + + for (int i = 0; i < livestockList.length; i += chunkSize) { + batches.add(livestockList.sublist(i, min(i + chunkSize, livestockList.length))); + } + return batches; + } + void addLiveStock() async { livestockList.add( Livestock(