Add files via upload

filcnaplo_kreta_api/lib/providers/absence_provider.dart

@@ -0,0 +1,73 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/absence.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class AbsenceProvider with ChangeNotifier {
+  late List<Absence> _absences;
+  late BuildContext _context;
+  List<Absence> get absences => _absences;
+
+  AbsenceProvider({
+    List<Absence> initialAbsences = const [],
+    required BuildContext context,
+  }) {
+    _absences = List.castFrom(initialAbsences);
+    _context = context;
+
+    if (_absences.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load absences from the database
+    if (userId != null) {
+      var dbAbsences = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getAbsences(userId: userId);
+      _absences = dbAbsences;
+      await convertBySettings();
+    }
+  }
+
+  // for renamed subjects
+  Future<void> convertBySettings() async {
+    final _database = Provider.of<DatabaseProvider>(_context, listen: false);
+    Map<String, String> renamedSubjects = (await _database.query.getSettings(_database)).renamedSubjectsEnabled
+        ? await _database.userQuery.renamedSubjects(userId: Provider.of<UserProvider>(_context, listen: false).user!.id)
+        : {};
+
+    for (Absence absence in _absences) {
+      absence.subject.renamedTo = renamedSubjects.isNotEmpty ? renamedSubjects[absence.subject.id] : null;
+    }
+
+    notifyListeners();
+  }
+
+  // Fetches Absences from the Kreta API then stores them in the database
+  Future<void> fetch() async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Absences for User null";
+    String iss = user.instituteCode;
+
+    List? absencesJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.absences(iss));
+    if (absencesJson == null) throw "Cannot fetch Absences for User ${user.id}";
+    List<Absence> absences = absencesJson.map((e) => Absence.fromJson(e)).toList();
+
+    if (absences.isNotEmpty || _absences.isNotEmpty) await store(absences);
+  }
+
+  // Stores Absences in the database
+  Future<void> store(List<Absence> absences) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Absences for User null";
+    String userId = user.id;
+
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeAbsences(absences, userId: userId);
+    _absences = absences;
+    await convertBySettings();
+  }
+}

filcnaplo_kreta_api/lib/providers/event_provider.dart

@@ -0,0 +1,59 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/event.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class EventProvider with ChangeNotifier {
+  late List<Event> _events;
+  late BuildContext _context;
+  List<Event> get events => _events;
+
+  EventProvider({
+    List<Event> initialEvents = const [],
+    required BuildContext context,
+  }) {
+    _events = List.castFrom(initialEvents);
+    _context = context;
+
+    if (_events.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load events from the database
+    if (userId != null) {
+      var dbEvents = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getEvents(userId: userId);
+      _events = dbEvents;
+      notifyListeners();
+    }
+  }
+
+  // Fetches Events from the Kreta API then stores them in the database
+  Future<void> fetch() async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Events for User null";
+    String iss = user.instituteCode;
+    
+    List? eventsJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.events(iss));
+    if (eventsJson == null) throw "Cannot fetch Events for User ${user.id}";
+    List<Event> events = eventsJson.map((e) => Event.fromJson(e)).toList();
+
+    if (events.isNotEmpty || _events.isNotEmpty) await store(events);
+  }
+
+  // Stores Events in the database
+  Future<void> store(List<Event> events) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Events for User null";
+    String userId = user.id;
+
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeEvents(events, userId: userId);
+    _events = events;
+    notifyListeners();
+  }
+}

filcnaplo_kreta_api/lib/providers/exam_provider.dart

@@ -0,0 +1,59 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/exam.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class ExamProvider with ChangeNotifier {
+  late List<Exam> _exams;
+  late BuildContext _context;
+  List<Exam> get exams => _exams;
+
+  ExamProvider({
+    List<Exam> initialExams = const [],
+    required BuildContext context,
+  }) {
+    _exams = List.castFrom(initialExams);
+    _context = context;
+
+    if (_exams.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load exams from the database
+    if (userId != null) {
+      var dbExams = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getExams(userId: userId);
+      _exams = dbExams;
+      notifyListeners();
+    }
+  }
+
+  // Fetches Exams from the Kreta API then stores them in the database
+  Future<void> fetch() async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Exams for User null";
+    String iss = user.instituteCode;
+
+    List? examsJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.exams(iss));
+    if (examsJson == null) throw "Cannot fetch Exams for User ${user.id}";
+    List<Exam> exams = examsJson.map((e) => Exam.fromJson(e)).toList();
+
+    if (exams.isNotEmpty || _exams.isNotEmpty) await store(exams);
+  }
+
+  // Stores Exams in the database
+  Future<void> store(List<Exam> exams) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Exams for User null";
+    String userId = user.id;
+
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeExams(exams, userId: userId);
+    _exams = exams;
+    notifyListeners();
+  }
+}

filcnaplo_kreta_api/lib/providers/grade_provider.dart

@@ -0,0 +1,134 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/settings.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/grade.dart';
+import 'package:filcnaplo_kreta_api/models/group_average.dart';
+import 'package:flutter/material.dart';
+
+class GradeProvider with ChangeNotifier {
+  // Private
+  late List<Grade> _grades;
+  late DateTime _lastSeen;
+  late String _groups;
+  List<GroupAverage> _groupAvg = [];
+  late final SettingsProvider _settings;
+  late final UserProvider _user;
+  late final DatabaseProvider _database;
+  late final KretaClient _kreta;
+
+  // Public
+  List<Grade> get grades => _grades;
+  DateTime get lastSeenDate => _settings.gradeOpeningFun ? _lastSeen : DateTime(3000);
+  String get groups => _groups;
+  List<GroupAverage> get groupAverages => _groupAvg;
+
+  GradeProvider({
+    List<Grade> initialGrades = const [],
+    required SettingsProvider settings,
+    required UserProvider user,
+    required DatabaseProvider database,
+    required KretaClient kreta,
+  }) {
+    _settings = settings;
+    _user = user;
+    _database = database;
+    _kreta = kreta;
+
+    _grades = List.castFrom(initialGrades);
+    _lastSeen = DateTime.now();
+
+    if (_grades.isEmpty) restore();
+  }
+
+  Future<void> seenAll() async {
+    String? userId = _user.id;
+    if (userId != null) {
+      final userStore = _database.userStore;
+      userStore.storeLastSeenGrade(DateTime.now(), userId: userId);
+      _lastSeen = DateTime.now();
+      notifyListeners();
+    }
+  }
+
+  Future<void> restore() async {
+    String? userId = _user.id;
+
+    // Load grades from the database
+    if (userId != null) {
+      final userQuery = _database.userQuery;
+
+      _grades = await userQuery.getGrades(userId: userId);
+      await convertBySettings();
+      _groupAvg = await userQuery.getGroupAverages(userId: userId);
+      notifyListeners();
+      DateTime lastSeenDB = await userQuery.lastSeenGrade(userId: userId);
+      if (lastSeenDB.millisecondsSinceEpoch == 0 || lastSeenDB.year == 0 || !_settings.gradeOpeningFun) {
+        _lastSeen = DateTime.now();
+        await seenAll();
+      } else {
+        _lastSeen = lastSeenDB;
+      }
+      notifyListeners();
+    }
+  }
+
+  // good student mode, renamed subjects
+  Future<void> convertBySettings() async {
+    Map<String, String> renamedSubjects = _settings.renamedSubjectsEnabled ? await _database.userQuery.renamedSubjects(userId: _user.user!.id) : {};
+
+    for (Grade grade in _grades) {
+      grade.subject.renamedTo = renamedSubjects.isNotEmpty ? renamedSubjects[grade.subject.id] : null;
+      grade.value.value = _settings.goodStudent ? 5 : grade.json!["SzamErtek"] ?? 0;
+      grade.value.valueName = _settings.goodStudent ? "Példás" : grade.json!["SzovegesErtek"] ?? "";
+      grade.value.shortName = _settings.goodStudent ? "Példás" : grade.json!["SzovegesErtekelesRovidNev"] ?? "";
+    }
+
+    notifyListeners();
+  }
+
+  // Fetches Grades from the Kreta API then stores them in the database
+  Future<void> fetch() async {
+    User? user = _user.user;
+    if (user == null) throw "Cannot fetch Grades for User null";
+    String iss = user.instituteCode;
+
+    List? gradesJson = await _kreta.getAPI(KretaAPI.grades(iss));
+    if (gradesJson == null) throw "Cannot fetch Grades for User ${user.id}";
+    List<Grade> grades = gradesJson.map((e) => Grade.fromJson(e)).toList();
+
+    if (grades.isNotEmpty || _grades.isNotEmpty) await store(grades);
+
+    List? groupsJson = await _kreta.getAPI(KretaAPI.groups(iss));
+    if (groupsJson == null || groupsJson.isEmpty) throw "Cannot fetch Groups for User ${user.id}";
+    _groups = (groupsJson[0]["OktatasNevelesiFeladat"] ?? {})["Uid"] ?? "";
+
+    List? groupAvgJson = await _kreta.getAPI(KretaAPI.groupAverages(iss, _groups));
+    if (groupAvgJson == null) throw "Cannot fetch Class Averages for User ${user.id}";
+    final groupAvgs = groupAvgJson.map((e) => GroupAverage.fromJson(e)).toList();
+    await storeGroupAvg(groupAvgs);
+  }
+
+  // Stores Grades in the database
+  Future<void> store(List<Grade> grades) async {
+    User? user = _user.user;
+    if (user == null) throw "Cannot store Grades for User null";
+    String userId = user.id;
+
+    await _database.userStore.storeGrades(grades, userId: userId);
+    _grades = grades;
+    await convertBySettings();
+  }
+
+  Future<void> storeGroupAvg(List<GroupAverage> groupAvgs) async {
+    _groupAvg = groupAvgs;
+
+    User? user = _user.user;
+    if (user == null) throw "Cannot store Grades for User null";
+    String userId = user.id;
+    await _database.userStore.storeGroupAverages(groupAvgs, userId: userId);
+    notifyListeners();
+  }
+}

filcnaplo_kreta_api/lib/providers/homework_provider.dart

@@ -0,0 +1,65 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/homework.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class HomeworkProvider with ChangeNotifier {
+  late List<Homework> _homework;
+  late BuildContext _context;
+  List<Homework> get homework => _homework;
+
+  HomeworkProvider({
+    List<Homework> initialHomework = const [],
+    required BuildContext context,
+  }) {
+    _homework = List.castFrom(initialHomework);
+    _context = context;
+
+    if (_homework.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load homework from the database
+    if (userId != null) {
+      var dbHomework = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getHomework(userId: userId);
+      _homework = dbHomework;
+      notifyListeners();
+    }
+  }
+
+  // Fetches Homework from the Kreta API then stores them in the database
+  Future<void> fetch({DateTime? from, bool db = true}) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Homework for User null";
+
+    String iss = user.instituteCode;
+    List? homeworkJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.homework(iss, start: from));
+    if (homeworkJson == null) throw "Cannot fetch Homework for User ${user.id}";
+
+    List<Homework> homework = [];
+    await Future.forEach(homeworkJson.cast<Map>(), (Map hw) async {
+      Map? e = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.homework(iss, id: hw["Uid"]));
+      if (e != null) homework.add(Homework.fromJson(e));
+    });
+    
+    if (homework.isEmpty && _homework.isEmpty) return;
+
+    if (db) await store(homework);
+    _homework = homework;
+    notifyListeners();
+  }
+
+  // Stores Homework in the database
+  Future<void> store(List<Homework> homework) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Homework for User null";
+    String userId = user.id;
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeHomework(homework, userId: userId);
+  }
+}

filcnaplo_kreta_api/lib/providers/message_provider.dart

@@ -0,0 +1,80 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/message.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class MessageProvider with ChangeNotifier {
+  late List<Message> _messages;
+  late BuildContext _context;
+  List<Message> get messages => _messages;
+
+  MessageProvider({
+    List<Message> initialMessages = const [],
+    required BuildContext context,
+  }) {
+    _messages = List.castFrom(initialMessages);
+    _context = context;
+
+    if (_messages.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load messages from the database
+    if (userId != null) {
+      var dbMessages = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getMessages(userId: userId);
+      _messages = dbMessages;
+      notifyListeners();
+    }
+  }
+
+  // Fetches all types of Messages
+  Future<void> fetchAll() => Future.forEach(MessageType.values, (MessageType v) => fetch(type: v));
+
+  // Fetches Messages from the Kreta API then stores them in the database
+  Future<void> fetch({MessageType type = MessageType.inbox}) async {
+    // Check Message Type
+    if (type == MessageType.draft) return;
+    String messageType = ["beerkezett", "elkuldott", "torolt"].elementAt(type.index);
+
+    // Check User
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Messages for User null";
+
+    // Get messages
+    List? messagesJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.messages(messageType));
+    if (messagesJson == null) throw "Cannot fetch Messages for User ${user.id}";
+
+    // Parse messages
+    List<Message> messages = [];
+    await Future.wait(List.generate(messagesJson.length, (index) {
+      return () async {
+        Map message = messagesJson.cast<Map>()[index];
+        Map? messageJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.message(message["azonosito"].toString()));
+        if (messageJson != null) messages.add(Message.fromJson(messageJson, forceType: type));
+      }();
+    }));
+
+    await store(messages, type);
+  }
+
+  // Stores Messages in the database
+  Future<void> store(List<Message> messages, MessageType type) async {
+    // Only store the specified type
+    _messages.removeWhere((m) => m.type == type);
+    _messages.addAll(messages);
+
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Messages for User null";
+
+    String userId = user.id;
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeMessages(_messages, userId: userId);
+
+    notifyListeners();
+  }
+}

filcnaplo_kreta_api/lib/providers/note_provider.dart

@@ -0,0 +1,59 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/note.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class NoteProvider with ChangeNotifier {
+  late List<Note> _notes;
+  late BuildContext _context;
+  List<Note> get notes => _notes;
+
+  NoteProvider({
+    List<Note> initialNotes = const [],
+    required BuildContext context,
+  }) {
+    _notes = List.castFrom(initialNotes);
+    _context = context;
+
+    if (_notes.isEmpty) restore();
+  }
+
+  Future<void> restore() async {
+    String? userId = Provider.of<UserProvider>(_context, listen: false).id;
+
+    // Load notes from the database
+    if (userId != null) {
+      var dbNotes = await Provider.of<DatabaseProvider>(_context, listen: false).userQuery.getNotes(userId: userId);
+      _notes = dbNotes;
+      notifyListeners();
+    }
+  }
+
+  // Fetches Notes from the Kreta API then stores them in the database
+  Future<void> fetch() async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot fetch Notes for User null";
+    String iss = user.instituteCode;
+
+    List? notesJson = await Provider.of<KretaClient>(_context, listen: false).getAPI(KretaAPI.notes(iss));
+    if (notesJson == null) throw "Cannot fetch Notes for User ${user.id}";
+    List<Note> notes = notesJson.map((e) => Note.fromJson(e)).toList();
+
+    if (notes.isNotEmpty || _notes.isNotEmpty) await store(notes);
+  }
+
+  // Stores Notes in the database
+  Future<void> store(List<Note> notes) async {
+    User? user = Provider.of<UserProvider>(_context, listen: false).user;
+    if (user == null) throw "Cannot store Notes for User null";
+    String userId = user.id;
+
+    await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeNotes(notes, userId: userId);
+    _notes = notes;
+    notifyListeners();
+  }
+}

filcnaplo_kreta_api/lib/providers/timetable_provider.dart

@@ -0,0 +1,92 @@
+import 'package:filcnaplo/api/providers/user_provider.dart';
+import 'package:filcnaplo/api/providers/database_provider.dart';
+import 'package:filcnaplo/models/user.dart';
+import 'package:filcnaplo_kreta_api/client/api.dart';
+import 'package:filcnaplo_kreta_api/client/client.dart';
+import 'package:filcnaplo_kreta_api/models/lesson.dart';
+import 'package:filcnaplo_kreta_api/models/week.dart';
+import 'package:flutter/material.dart';
+
+class TimetableProvider with ChangeNotifier {
+  Map<Week, List<Lesson>> _lessons = {};
+  late final UserProvider _user;
+  late final DatabaseProvider _database;
+  late final KretaClient _kreta;
+
+  TimetableProvider({
+    required UserProvider user,
+    required DatabaseProvider database,
+    required KretaClient kreta,
+  })  : _user = user,
+        _database = database,
+        _kreta = kreta {
+    restoreUser();
+  }
+
+  Future<void> restoreUser() async {
+    String? userId = _user.id;
+
+    // Load lessons from the database
+    if (userId != null) {
+      var dbLessons = await _database.userQuery.getLessons(userId: userId);
+      _lessons = dbLessons;
+      await convertBySettings();
+    }
+  }
+
+  // for renamed subjects
+  Future<void> convertBySettings() async {
+    Map<String, String> renamedSubjects =
+        (await _database.query.getSettings(_database)).renamedSubjectsEnabled ? await _database.userQuery.renamedSubjects(userId: _user.id!) : {};
+
+    for (Lesson lesson in _lessons.values.expand((e) => e)) {
+      lesson.subject.renamedTo = renamedSubjects.isNotEmpty ? renamedSubjects[lesson.subject.id] : null;
+    }
+
+    notifyListeners();
+  }
+
+  List<Lesson>? getWeek(Week week) => _lessons[week];
+
+  // Fetches Lessons from the Kreta API then stores them in the database
+  Future<void> fetch({Week? week}) async {
+    if (week == null) return;
+    User? user = _user.user;
+    if (user == null) throw "Cannot fetch Lessons for User null";
+    String iss = user.instituteCode;
+    List? lessonsJson = await _kreta.getAPI(KretaAPI.timetable(iss, start: week.start, end: week.end));
+    if (lessonsJson == null) throw "Cannot fetch Lessons for User ${user.id}";
+    List<Lesson> lessons = lessonsJson.map((e) => Lesson.fromJson(e)).toList();
+
+    if (lessons.isEmpty && _lessons.isEmpty) return;
+
+    _lessons[week] = lessons;
+
+    await store();
+    await convertBySettings();
+  }
+
+  // Stores Lessons in the database
+  Future<void> store() async {
+    User? user = _user.user;
+    if (user == null) throw "Cannot store Lessons for User null";
+    String userId = user.id;
+
+    // TODO: clear indexes with weeks outside of the current school year
+    await _database.userStore.storeLessons(_lessons, userId: userId);
+  }
+
+  // Future<void> setLessonCount(SubjectLessonCount lessonCount, {bool store = true}) async {
+  //   _subjectLessonCount = lessonCount;
+
+  //   if (store) {
+  //     User? user = Provider.of<UserProvider>(_context, listen: false).user;
+  //     if (user == null) throw "Cannot store Lesson Count for User null";
+  //     String userId = user.id;
+
+  //     await Provider.of<DatabaseProvider>(_context, listen: false).userStore.storeSubjectLessonCount(lessonCount, userId: userId);
+  //   }
+
+  //   notifyListeners();
+  // }
+}