fcs/lib/pages/carton/model/carton_model.dart

import 'dart:async';

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:fcs/data/services/services.dart';
import 'package:fcs/domain/constants.dart';
import 'package:fcs/domain/entities/carton.dart';
import 'package:fcs/domain/vo/message.dart';
import 'package:fcs/domain/vo/shipment_status.dart';
import 'package:fcs/helpers/paginator.dart';
import 'package:fcs/pages/main/model/base_model.dart';
import 'package:logging/logging.dart';

class CartonModel extends BaseModel {
  List<Carton> _boxes = [];
  final log = Logger('CartonModel');
  List<Carton> get boxes =>
      _selectedIndex == 1 ? _boxes : List<Carton>.from(_delivered.values);

  Paginator _delivered;
  int _selectedIndex = 1;
  bool isLoading = false;

  StreamSubscription<QuerySnapshot> listener;
  static List<ShipmentStatus> statusHistory = [
    ShipmentStatus(status: "Packed", date: DateTime(2020, 6, 1), done: true),
    ShipmentStatus(status: "Shipped", date: DateTime(2020, 6, 5), done: false),
    ShipmentStatus(
        status: "Delivered", date: DateTime(2020, 6, 15), done: false)
  ];

  List<Carton> get completed {
    return boxes.where((e) => e.status == "Delivered").toList()
      ..sort((e1, e2) {
        return e2.packageNumber.compareTo(e1.packageNumber);
      });
  }

  List<Carton> get processed {
    return boxes.where((e) => e.status == "Packed").toList()
      ..sort((e1, e2) {
        return e2.packageNumber.compareTo(e1.packageNumber);
      });
  }

  List<Carton> get upcoming {
    return boxes
        .where((e) =>
            e.status == "Packed" ||
            // e.status == "Received" ||
            e.status == "Shipped" ||
            e.status == "Arrived")
        .toList()
          ..sort((e1, e2) {
            return e2.packageNumber.compareTo(e1.packageNumber);
          });
  }

  List<String> cartonTypes = [
    carton_from_packages,
    carton_mix_box,
    carton_small_bag
  ];
  List<String> cartonTypesInfo = [
    carton_from_packages,
    carton_mix_box,
    carton_from_shipments,
    carton_small_bag
  ];

  set selectedIndex(int index) {
    _selectedIndex = index;
    notifyListeners();
  }

  get selectedIndex => _selectedIndex;

  initData() {
    _selectedIndex = 1;
    _loadBoxes();

    if (_delivered != null) _delivered.close();
    _delivered = _getDelivered();
    _delivered.load();
  }

  Future<void> _loadBoxes() async {
    if (user == null || !user.hasCarton()) return;
    String path = "/$cartons_collection/";
    if (listener != null) listener.cancel();
    _boxes = [];
    try {
      listener = Firestore.instance
          .collection("$path")
          .where("status",
              whereIn: [carton_packed_status, carton_shipped_status])
          .where("is_deleted", isEqualTo: false)
          .orderBy("created_at", descending: true)
          .snapshots()
          .listen((QuerySnapshot snapshot) {
            _boxes.clear();
            _boxes = snapshot.documents.map((documentSnapshot) {
              var s = Carton.fromMap(
                  documentSnapshot.data, documentSnapshot.documentID);
              return s;
            }).toList();
            notifyListeners();
          });
    } catch (e) {
      log.warning("Error!! $e");
    }
  }

  Paginator _getDelivered() {
    if (user == null || !user.hasCarton()) return null;

    var pageQuery = Firestore.instance
        .collection("/$cartons_collection")
        .where("is_delivered", isEqualTo: true)
        .where("is_deleted", isEqualTo: false);
    var paginator = new Paginator(pageQuery, rowPerLoad: 20, toObj: (data, id) {
      return Carton.fromMap(data, id);
    });
    return paginator;
  }

  Future<void> loadMore() async {
    if (_delivered.ended || selectedIndex == 1) return;
    isLoading = true;
    notifyListeners();
    await _delivered.load(onFinished: () {
      isLoading = false;
      notifyListeners();
    });
  }

  Future<void> refresh() async {
    if (selectedIndex == 1) return;
    await _delivered.refresh(onFinished: () {
      notifyListeners();
    });
  }

  void initUser(user) {
    super.initUser(user);
  }

  @override
  logout() async {
    if (listener != null) await listener.cancel();
    if (_delivered != null) _delivered.close();
    _boxes = [];
  }

  Future<List<Carton>> getCartons(String shipmentID) async {
    String path = "/$cartons_collection";
    var querySnap = await Firestore.instance
        .collection(path)
        .where("shipment_id", isEqualTo: shipmentID)
        .getDocuments();
    return querySnap.documents
        .map((e) => Carton.fromMap(e.data, e.documentID))
        .toList();
  }

  Future<List<Carton>> getCartonsByFcsShipment(String fcsShipmentID) async {
    String path = "/$cartons_collection";
    var querySnap = await Firestore.instance
        .collection(path)
        .where("fcs_shipment_id", isEqualTo: fcsShipmentID)
        .where("is_deleted", isEqualTo: false)
        .getDocuments();
    return querySnap.documents
        .map((e) => Carton.fromMap(e.data, e.documentID))
        .toList();
  }

  Future<List<Carton>> getCartonsForInvoice(
      String fcsShipmentID, String userID) async {
    String path = "/$cartons_collection";
    var querySnap = await Firestore.instance
        .collection(path)
        .where("fcs_shipment_id", isEqualTo: fcsShipmentID)
        .where("user_id", isEqualTo: userID)
        .where("is_deleted", isEqualTo: false)
        .where("is_invoiced", isEqualTo: false)
        .getDocuments();
    List<Carton> cartons = querySnap.documents
        .map((e) => Carton.fromMap(e.data, e.documentID))
        .toList();
    return cartons;
  }

  Future<List<Carton>> getMixCartonsByFcsShipment(String fcsShipmentID) async {
    String path = "/$cartons_collection";
    var querySnap = await Firestore.instance
        .collection(path)
        .where("fcs_shipment_id", isEqualTo: fcsShipmentID)
        .where("carton_type", isEqualTo: carton_mix_box)
        .where("is_deleted", isEqualTo: false)
        .getDocuments();
    return querySnap.documents
        .map((e) => Carton.fromMap(e.data, e.documentID))
        .toList();
  }

  Future<Carton> getCarton(String id) async {
    String path = "/$cartons_collection";
    var snap = await Firestore.instance.collection(path).document(id).get();
    return Carton.fromMap(snap.data, snap.documentID);
  }

  Future<void> createCarton(Carton carton) {
    return Services.instance.cartonService.createCarton(carton);
  }

  Future<void> updateCarton(Carton carton) {
    return Services.instance.cartonService.updateCarton(carton);
  }

  Future<void> deleteCarton(Carton carton) {
    return Services.instance.cartonService.deleteCarton(carton);
  }
}