Rename everything filcnaplo-related to refilc

refilc_kreta_api/lib/providers/absence_provider.dart

@@ -0,0 +1,94 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_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)
+            : {};
+    Map<String, String> renamedTeachers =
+        (await _database.query.getSettings(_database)).renamedTeachersEnabled
+            ? await _database.userQuery.renamedTeachers(
+                userId:
+                    Provider.of<UserProvider>(_context, listen: false).user!.id)
+            : {};
+
+    for (Absence absence in _absences) {
+      absence.subject.renamedTo = renamedSubjects.isNotEmpty
+          ? renamedSubjects[absence.subject.id]
+          : null;
+      absence.teacher.renamedTo = renamedTeachers.isNotEmpty
+          ? renamedTeachers[absence.teacher.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();
+  }
+}

refilc_kreta_api/lib/providers/event_provider.dart

@@ -0,0 +1,65 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_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();
+  }
+}

refilc_kreta_api/lib/providers/exam_provider.dart

@@ -0,0 +1,64 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_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();
+  }
+}

refilc_kreta_api/lib/providers/grade_provider.dart

@@ -0,0 +1,165 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/settings.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_kreta_api/models/grade.dart';
+import 'package:refilc_kreta_api/models/group_average.dart';
+import 'package:refilc_kreta_api/providers/grade_provider.i18n.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();
+    }
+  }
+
+  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)
+        : {};
+    Map<String, String> renamedTeachers = _settings.renamedTeachersEnabled
+        ? await _database.userQuery.renamedTeachers(userId: _user.user!.id)
+        : {};
+
+    for (Grade grade in _grades) {
+      grade.subject.renamedTo =
+          renamedSubjects.isNotEmpty ? renamedSubjects[grade.subject.id] : null;
+      grade.teacher.renamedTo =
+          renamedTeachers.isNotEmpty ? renamedTeachers[grade.teacher.id] : null;
+
+      grade.value.value =
+          _settings.goodStudent ? 5 : grade.json!["SzamErtek"] ?? 0;
+      grade.value.valueName = _settings.goodStudent
+          ? "Jeles".i18n
+          : '${grade.json!["SzovegesErtek"]}'
+              .replaceAll(RegExp(r'[(]+[12345]?[)]'), '')
+              .i18n;
+      grade.value.shortName = _settings.goodStudent
+          ? "Jeles".i18n
+          : '${grade.json!["SzovegesErtekelesRovidNev"]}' != "null" &&
+                  '${grade.json!["SzovegesErtekelesRovidNev"]}' != "-" &&
+                  '${grade.json!["SzovegesErtekelesRovidNev"]}'
+                          .replaceAll(RegExp(r'[0123456789]+[%]?'), '') !=
+                      ""
+              ? '${grade.json!["SzovegesErtekelesRovidNev"]}'.i18n
+              : grade.value.valueName;
+    }
+
+    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();
+  }
+}

refilc_kreta_api/lib/providers/grade_provider.i18n.dart

@@ -0,0 +1,33 @@
+import 'package:i18n_extension/i18n_extension.dart';
+
+extension Localization on String {
+  static final _t = Translations.byLocale("hu_hu") +
+      {
+        "en_en": {
+          "Elégtelen": "Fail",
+          "Elégséges": "Warning but passing",
+          "Közepes": "Passed",
+          "Jó": "Good",
+          "Jeles": "Excellent"
+        },
+        "hu_hu": {
+          "Elégtelen": "Elégtelen",
+          "Elégséges": "Elégséges",
+          "Közepes": "Közepes",
+          "Jó": "Jó",
+          "Jeles": "Jeles"
+        },
+        "de_de": {
+          "Elégtelen": "Ungenügend",
+          "Elégséges": "Mangelhaft",
+          "Közepes": "Ausreichend",
+          "Jó": "Befriedigend",
+          "Jeles": "Gut"
+        },
+      };
+
+  String get i18n => localize(this, _t);
+  String fill(List<Object> params) => localizeFill(this, params);
+  String plural(int value) => localizePlural(value, this, _t);
+  String version(Object modifier) => localizeVersion(modifier, this, _t);
+}

refilc_kreta_api/lib/providers/homework_provider.dart

@@ -0,0 +1,124 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/settings.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_kreta_api/models/homework.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+class HomeworkProvider with ChangeNotifier {
+  // Private
+  late final SettingsProvider _settings;
+  late final UserProvider _user;
+  late final DatabaseProvider _database;
+
+  // Public
+  late List<Homework> _homework;
+  late BuildContext _context;
+  List<Homework> get homework => _homework;
+
+  HomeworkProvider({
+    List<Homework> initialHomework = const [],
+    required BuildContext context,
+    required DatabaseProvider database,
+  }) {
+    _homework = List.castFrom(initialHomework);
+    _context = context;
+    _database = database;
+
+    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;
+      await convertBySettings();
+    }
+  }
+
+  Future<void> convertBySettings() async {
+    Map<String, String> renamedSubjects =
+        (await _database.query.getSettings(_database)).renamedSubjectsEnabled
+            ? await _database.userQuery.renamedSubjects(userId: _user.id!)
+            : {};
+    Map<String, String> renamedTeachers =
+        (await _database.query.getSettings(_database)).renamedTeachersEnabled
+            ? await _database.userQuery.renamedTeachers(userId: _user.id!)
+            : {};
+
+    for (Homework homework in _homework) {
+      homework.subject.renamedTo = renamedSubjects.isNotEmpty
+          ? renamedSubjects[homework.subject.id]
+          : null;
+      homework.teacher.renamedTo = renamedTeachers.isNotEmpty
+          ? renamedTeachers[homework.teacher.id]
+          : null;
+    }
+
+    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 = [];
+
+    try {
+      homeworkJson = await Provider.of<KretaClient>(_context, listen: false)
+          .getAPI(KretaAPI.homework(iss, start: from));
+    } catch (e) {
+      // error fetcing homework (unknown error)
+    }
+
+    if (homeworkJson == null) {
+      if (kDebugMode) print("Cannot fetch Homework for User ${user.id}");
+      return;
+    }
+
+    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"]));
+      Map<String, String> renamedSubjects = _settings.renamedSubjectsEnabled
+          ? await _database.userQuery.renamedSubjects(userId: _user.user!.id)
+          : {};
+
+      if (e != null) {
+        Homework hw = Homework.fromJson(e);
+        hw.subject.renamedTo =
+            renamedSubjects.isNotEmpty ? renamedSubjects[hw.subject.id] : null;
+        homework.add(hw);
+      }
+    });
+
+    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);
+  }
+}

refilc_kreta_api/lib/providers/message_provider.dart

@@ -0,0 +1,91 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_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();
+  }
+}

refilc_kreta_api/lib/providers/note_provider.dart

@@ -0,0 +1,64 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_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();
+  }
+}

refilc_kreta_api/lib/providers/timetable_provider.dart

@@ -0,0 +1,110 @@
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/client/api.dart';
+import 'package:refilc_kreta_api/client/client.dart';
+import 'package:refilc_kreta_api/models/lesson.dart';
+import 'package:refilc_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!)
+            : {};
+    Map<String, String> renamedTeachers =
+        (await _database.query.getSettings(_database)).renamedTeachersEnabled
+            ? await _database.userQuery.renamedTeachers(userId: _user.id!)
+            : {};
+
+    for (Lesson lesson in lessons.values.expand((e) => e)) {
+      lesson.subject.renamedTo = renamedSubjects.isNotEmpty
+          ? renamedSubjects[lesson.subject.id]
+          : null;
+      lesson.teacher.renamedTo = renamedTeachers.isNotEmpty
+          ? renamedTeachers[lesson.teacher.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) {
+      return;
+      // throw "Cannot fetch Lessons for User ${user.id}";
+    } else {
+      List<Lesson> lessonsList =
+          lessonsJson.map((e) => Lesson.fromJson(e)).toList();
+
+      if (lessons.isEmpty) return;
+
+      lessons[week] = lessonsList;
+
+      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();
+  // }
+}