add pagination

lib/pages/package/model/package_model.dart

@@ -8,116 +8,126 @@ import 'package:fcs/domain/entities/package.dart';
 import 'package:fcs/domain/entities/user.dart';
 import 'package:fcs/domain/vo/delivery_address.dart';
 import 'package:fcs/helpers/firebase_helper.dart';
-import 'package:fcs/helpers/paginator.dart';
 import 'package:fcs/pages/main/model/base_model.dart';
+import 'package:fcs/pagination/paginator_listener.dart';
 import 'package:logging/logging.dart';
 import 'package:path/path.dart' as Path;
 
 class PackageModel extends BaseModel {
   final log = Logger('PackageModel');
 
-  StreamSubscription<QuerySnapshot> listener;
+  PaginatorListener packages;
+  PaginatorListener customerPackages;
+  PaginatorListener activePackages;
 
-  List<Package> get packages => _menuSelectedIndex == 1
-      ? _packages
-      : List<Package>.from(_delivered.values);
-
-  List<Package> _packages = [];
-
-  Paginator _delivered;
   bool isLoading = false;
   int _menuSelectedIndex = 1;
 
   set menuSelectedIndex(int index) {
     _menuSelectedIndex = index;
+
+    _loadPackages(_menuSelectedIndex == 2);
+    _loadCustomerPackages(_menuSelectedIndex == 2);
+
     notifyListeners();
   }
 
   get menuSelectedIndex => _menuSelectedIndex;
 
-  initData(bool forCustomer) {
+  void privilegeChanged() {
+    if (user != null) {
+      _initData();
+    }
+  }
+
+  Future<void> _initData() async {
     logout();
     _menuSelectedIndex = 1;
-    _loadPackages(forCustomer);
-    _delivered = _getDelivered(forCustomer);
-    _delivered.load();
+    packages = PaginatorListener<Package>(
+        (data, id) => Package.fromMap(data, id), onChange: () {
+      notifyListeners();
+    }, rowPerLoad: 30, insertNewByListener: true);
+    customerPackages = PaginatorListener<Package>(
+        (data, id) => Package.fromMap(data, id), onChange: () {
+      notifyListeners();
+    }, rowPerLoad: 30, insertNewByListener: true);
+    activePackages = PaginatorListener<Package>(
+        (data, id) => Package.fromMap(data, id), onChange: () {
+      notifyListeners();
+    }, rowPerLoad: 30, insertNewByListener: true);
+
+    _loadPackages(_menuSelectedIndex == 2);
+    _loadCustomerPackages(_menuSelectedIndex == 2);
+    _loadActivePackages();
   }
 
   @override
   logout() async {
-    if (_delivered != null) _delivered.close();
-    if (listener != null) await listener.cancel();
-    _packages = [];
+    if (customerPackages != null) customerPackages.close();
+    if (packages != null) packages.close();
+    if (activePackages != null) activePackages.close();
   }
 
-  Future<void> loadMore({bool isCustomer}) async {
-    if (_delivered.ended || menuSelectedIndex == 1)
-      return; // when delivered menu is not selected return
-    isLoading = true;
-    notifyListeners();
-    await _delivered.load(onFinished: () {
-      isLoading = false;
-      notifyListeners();
-    });
-  }
-
-  Future<void> refresh({bool isCustomer}) async {
-    if (menuSelectedIndex == 1)
-      return; // when delivered menu is not selected return
-    await _delivered.refresh(onFinished: () {
-      notifyListeners();
-    });
-  }
-
-  Paginator _getDelivered(bool isCustomer) {
-    if (!isCustomer) {
-      if (user == null ||
-          !((user.hasPackages() ||
-              user.hasReceiving() ||
-              user.hasProcessing()))) throw "No privilege";
-    }
-    var pageQuery = Firestore.instance
-        .collection("/$packages_collection")
-        .where("is_delivered", isEqualTo: true)
-        .where("is_deleted", isEqualTo: false);
-    if (isCustomer) {
-      pageQuery = pageQuery.where("user_id", isEqualTo: user.id);
-    }
-    pageQuery = pageQuery.orderBy("status_date", descending: true);
-    var paginator = new Paginator(pageQuery, rowPerLoad: 20, toObj: (data, id) {
-      return Package.fromMap(data, id);
-    });
-    return paginator;
-  }
-
-  Future<void> _loadPackages(bool forCustomer) async {
+  Future<void> _loadPackages(bool isDelivered) async {
     if (user == null) return;
-    if (!forCustomer &&
-        !((user.hasPackages() || user.hasReceiving() || user.hasProcessing())))
+    if (!((user.hasPackages() || user.hasReceiving() || user.hasProcessing())))
       return;
     String path = "/$packages_collection";
-    if (listener != null) listener.cancel();
-    _packages = [];
 
     try {
-      var q = Firestore.instance
-          .collection("$path")
-          .where("is_delivered", isEqualTo: false)
-          .where("is_deleted", isEqualTo: false);
+      Query listenerQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: isDelivered);
+      Query pageQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: isDelivered);
 
-      if (forCustomer) {
-        q = q.where("user_id", isEqualTo: user.id);
-      }
-      q = q.orderBy("update_time", descending: true);
-      listener = q.snapshots().listen((QuerySnapshot snapshot) {
-        _packages.clear();
-        _packages = snapshot.documents.map((documentSnapshot) {
-          var package = Package.fromMap(
-              documentSnapshot.data, documentSnapshot.documentID);
-          return package;
-        }).toList();
-        notifyListeners();
-      });
+      pageQuery = pageQuery.orderBy("update_time", descending: true);
+      packages.refresh(listeningQuery: listenerQuery, pageQuery: pageQuery);
+    } catch (e) {
+      log.warning("Error!! $e");
+    }
+  }
+
+  Future<void> _loadCustomerPackages(bool isDelivered) async {
+    if (user == null) return;
+    String path = "/$packages_collection";
+
+    try {
+      Query listenerQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: isDelivered)
+          .where("user_id", isEqualTo: user.id);
+      Query pageQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: isDelivered)
+          .where("user_id", isEqualTo: user.id)
+          .orderBy("update_time", descending: true);
+
+      customerPackages.refresh(
+          listeningQuery: listenerQuery, pageQuery: pageQuery);
+    } catch (e) {
+      log.warning("Error!! $e");
+    }
+  }
+
+  Future<void> _loadActivePackages() async {
+    if (user == null) return;
+    if (!((user.hasPackages() || user.hasReceiving() || user.hasProcessing())))
+      return;
+    String path = "/$packages_collection";
+
+    try {
+      Query listenerQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: false);
+      Query pageQuery = Firestore.instance
+          .collection(path)
+          .where("is_delivered", isEqualTo: false);
+
+      pageQuery = pageQuery.orderBy("update_time", descending: true);
+      activePackages.refresh(
+          listeningQuery: listenerQuery, pageQuery: pageQuery);
     } catch (e) {
       log.warning("Error!! $e");
     }