fcs/lib/fcs/common/pages/model/main_model.dart

import 'dart:async';

import 'package:fcs/fcs/common/domain/entities/auth_result.dart';
import 'package:fcs/fcs/common/domain/entities/auth_status.dart';
import 'package:fcs/fcs/common/domain/entities/setting.dart';
import 'package:fcs/fcs/common/domain/entities/user.dart';
import 'package:fcs/fcs/common/helpers/network_connectivity.dart';
import 'package:fcs/fcs/common/helpers/shared_pref.dart';
import 'package:fcs/fcs/common/pages/model/base_model.dart';
import 'package:fcs/fcs/common/services/services.dart';
import 'package:flutter/foundation.dart';
import 'package:logging/logging.dart';
import 'package:package_info/package_info.dart';

class MainModel extends ChangeNotifier {
  final log = Logger('MainModel');
  List<BaseModel> models = [];

  User user;
  PackageInfo packageInfo;

  Setting setting;

  bool isLoaded = false;
  bool isOnline = false;
  bool isFirstLaunch = false;

  MainModel() {
    NetworkConnectivity.instance.statusStream.listen((data) {
      bool _isOnline = data["isOnline"];
      if (_isOnline && !this.isOnline) {
        init();
      }
      this.isOnline = _isOnline;
      notifyListeners();
    });
    Services.instance.authService.onAuthStatus().listen((event) {
      this.user = event;
      _initUser(user);
      notifyListeners();
    });
  }

  bool faqEditable() {
    return this.user != null && this.user.hasSupport();
  }

  bool termEditable() {
    return this.user != null && this.user.hasSupport();
  }

  bool contactEditable() {
    return this.user != null && this.user.hasSupport();
  }

  bool isLogin() {
    return this.user != null;
  }

  bool isCustomer() {
    return user != null && user.isCustomer();
  }

  bool isSysAdmin() {
    return this.user != null && this.user.hasSysAdmin();
  }

  bool isAdmin() {
    return this.user != null && this.user.hasAdmin();
  }

  init() async {
    await _loadSetting();
    this.isFirstLaunch = await SharedPref.isFirstLaunch();
    this.isFirstLaunch = this.isFirstLaunch ?? true;

    _loadUser();
    this.packageInfo = await PackageInfo.fromPlatform();
  }

  void addModel(BaseModel model) {
    models.add(model);
  }

  void _initUser(User user) {
    models.forEach((m) => m.initUser(user));

    // if (firebaseMessaging != null) {
    //   firebaseMessaging.subscribeToTopic(user.docID);
    // }
  }

  void _initSetting(Setting setting) {
    models.forEach((m) => m.initSetting(setting));
  }

  Future<void> _loadSetting() async {
    try {
      Services.instance.authService.getSetting().listen((event) {
        this.setting = event;
        _initSetting(setting);
        notifyListeners();
      });
    } finally {}
  }

  void _loadUser() async {
    try {
      this.user = await Services.instance.authService.getUser();
      _initUser(user);
    } finally {
      this.isLoaded = true;
      notifyListeners();
    }
  }

  @override
  void dispose() {
    super.dispose();
    // if (this.userListener != null) {
    //   this.userListener.cancel();
    // }
    // SharedPref.removeUser();
    // this.user = User();
  }

  bool isSupport() {
    if (packageInfo == null || setting == null) return false;
    return int.parse(packageInfo.buildNumber) >= setting.supportBuildNum;
  }

  Future<AuthResult> sendSms(String phoneNumber) {
    return Services.instance.authService.sendSmsCodeToPhoneNumber(phoneNumber);
  }

  Future<AuthResult> signin(String smsCode) async {
    AuthResult authResult =
        await Services.instance.authService.signInWithSmsCode(smsCode);
    if (authResult != null &&
        authResult.authStatus == AuthStatus.AUTH_VERIFIED) {
      this.user = await Services.instance.authService.getUser();
    }
    return authResult;
  }

  Future<void> signout() {
    this.user = null;
    // logout models
    models.forEach((m) => m.logout());
    notifyListeners();
    return Services.instance.authService.signout();
  }

  Future<bool> hasInvite() async {
    return Services.instance.authService.hasInvite();
  }

  Future<void> signup(String userName) async {
    await Services.instance.authService.signup(userName);
    this.user =
        await Services.instance.authService.getUser(refreshIdToken: true);
    notifyListeners();
  }

  Future<void> updateProfile(String newUserName) async {
    await Services.instance.authService.updateProfile(newUserName);
    this.user =
        await Services.instance.authService.getUser(refreshIdToken: true);
    notifyListeners();
  }
}