changed everything from filcnaplo to refilc finally

refilc/lib/database/init.dart

@@ -0,0 +1,202 @@
+// ignore_for_file: avoid_print
+
+import 'dart:io';
+
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/database/struct.dart';
+import 'package:refilc/models/settings.dart';
+import 'package:flutter/foundation.dart';
+// ignore: depend_on_referenced_packages
+import 'package:sqflite_common_ffi/sqflite_ffi.dart';
+import 'package:sqflite_common_ffi_web/sqflite_ffi_web.dart';
+
+const settingsDB = DatabaseStruct("settings", {
+  "language": String, "start_page": int, "rounding": int, "theme": int,
+  "accent_color": int, "news": int, "seen_news": String,
+  "developer_mode": int,
+  "update_channel": int, "config": String, "custom_accent_color": int,
+  "custom_background_color": int, "custom_highlight_color": int,
+  "custom_icon_color": int, "shadow_effect": int, // general
+  "grade_color1": int, "grade_color2": int, "grade_color3": int,
+  "grade_color4": int, "grade_color5": int, // grade colors
+  "vibration_strength": int, "ab_weeks": int, "swap_ab_weeks": int,
+  "notifications": int, "notifications_bitfield": int,
+  "notification_poll_interval": int,
+  "notifications_grades": int,
+  "notifications_absences": int,
+  "notifications_messages": int,
+  "notifications_lessons": int, // notifications
+  "x_filc_id": String, "graph_class_avg": int, "presentation_mode": int,
+  "bell_delay": int, "bell_delay_enabled": int,
+  "grade_opening_fun": int, "icon_pack": String, "premium_scopes": String,
+  "premium_token": String, "premium_login": String,
+  "last_account_id": String, "renamed_subjects_enabled": int,
+  "renamed_subjects_italics": int, "renamed_teachers_enabled": int,
+  "renamed_teachers_italics": int,
+  "live_activity_color": String,
+  "welcome_message": String, "app_icon": String,
+  // paints
+  "current_theme_id": String, "current_theme_display_name": String,
+  "current_theme_creator": String,
+  // pinned settings
+  "general_s_pin": String, "personalize_s_pin": String,
+  "notify_s_pin": String, "extras_s_pin": String,
+  // more
+  "show_breaks": int,
+  "font_family": String,
+});
+// DON'T FORGET TO UPDATE DEFAULT VALUES IN `initDB` MIGRATION OR ELSE PARENTS WILL COMPLAIN ABOUT THEIR CHILDREN MISSING
+// YOU'VE BEEN WARNED!!!
+const usersDB = DatabaseStruct("users", {
+  "id": String, "name": String, "username": String, "password": String,
+  "institute_code": String, "student": String, "role": int,
+  "nickname": String, "picture": String // premium only
+});
+const userDataDB = DatabaseStruct("user_data", {
+  "id": String, "grades": String, "timetable": String, "exams": String,
+  "homework": String, "messages": String, "recipients": String, "notes": String,
+  "events": String, "absences": String, "group_averages": String,
+  // renamed subjects // non kreta data
+  "renamed_subjects": String,
+  // renamed teachers // non kreta data
+  "renamed_teachers": String,
+  // "subject_lesson_count": String, // non kreta data
+  "last_seen_grade": int,
+  // goal planning // non kreta data
+  "goal_plans": String,
+  "goal_averages": String,
+  "goal_befores": String,
+  "goal_pin_dates": String,
+  // todo and notes
+  "todo_items": String, "self_notes": String,
+  // v5 shit
+  "roundings": String,
+  "grade_rarities": String,
+});
+
+Future<void> createTable(Database db, DatabaseStruct struct) =>
+    db.execute("CREATE TABLE IF NOT EXISTS ${struct.table} ($struct)");
+
+Future<Database> initDB(DatabaseProvider database) async {
+  Database db;
+
+  if (kIsWeb) {
+    db = await databaseFactoryFfiWeb.openDatabase("app.db");
+  } else if (Platform.isLinux || Platform.isWindows) {
+    sqfliteFfiInit();
+    db = await databaseFactoryFfi.openDatabase("app.db");
+  } else {
+    db = await openDatabase("app.db");
+  }
+
+  await createTable(db, settingsDB);
+  await createTable(db, usersDB);
+  await createTable(db, userDataDB);
+
+  if ((await db.rawQuery("SELECT COUNT(*) FROM settings"))[0].values.first ==
+      0) {
+    // Set default values for table Settings
+    await db.insert("settings",
+        SettingsProvider.defaultSettings(database: database).toMap());
+  }
+
+  // Migrate Databases
+  try {
+    await migrateDB(
+      db,
+      struct: settingsDB,
+      defaultValues:
+          SettingsProvider.defaultSettings(database: database).toMap(),
+    );
+    await migrateDB(
+      db,
+      struct: usersDB,
+      defaultValues: {"role": 0, "nickname": "", "picture": ""},
+    );
+    await migrateDB(db, struct: userDataDB, defaultValues: {
+      "grades": "[]", "timetable": "[]", "exams": "[]", "homework": "[]",
+      "messages": "[]", "recipients": "[]", "notes": "[]", "events": "[]",
+      "absences": "[]",
+      "group_averages": "[]",
+      // renamed subjects // non kreta data
+      "renamed_subjects": "{}",
+      // renamed teachers // non kreta data
+      "renamed_teachers": "{}",
+      // "subject_lesson_count": "{}", // non kreta data
+      "last_seen_grade": 0,
+      // goal planning // non kreta data
+      "goal_plans": "{}",
+      "goal_averages": "{}",
+      "goal_befores": "{}",
+      "goal_pin_dates": "{}",
+      // todo and notes
+      "todo_items": "{}", "self_notes": "[]",
+      // v5 shit
+      "roundings": "{}",
+      "grade_rarities": "{}",
+    });
+  } catch (error) {
+    print("ERROR: migrateDB: $error");
+  }
+
+  return db;
+}
+
+Future<void> migrateDB(
+  Database db, {
+  required DatabaseStruct struct,
+  required Map<String, Object?> defaultValues,
+}) async {
+  var originalRows = await db.query(struct.table);
+
+  if (originalRows.isEmpty) {
+    await db.execute("drop table ${struct.table}");
+    await createTable(db, struct);
+    return;
+  }
+
+  List<Map<String, dynamic>> migrated = [];
+
+  // go through each row and add missing keys or delete non existing keys
+  await Future.forEach<Map<String, Object?>>(originalRows, (original) async {
+    bool migrationRequired = struct.struct.keys.any(
+            (key) => !original.containsKey(key) || original[key] == null) ||
+        original.keys.any((key) => !struct.struct.containsKey(key));
+
+    if (migrationRequired) {
+      print("INFO: Migrating ${struct.table}");
+      var copy = Map<String, Object?>.from(original);
+
+      // Fill missing columns
+      for (var key in struct.struct.keys) {
+        if (!original.containsKey(key) || original[key] == null) {
+          print("DEBUG: migrating $key");
+          copy[key] = defaultValues[key];
+        }
+      }
+
+      for (var key in original.keys) {
+        if (!struct.struct.keys.contains(key)) {
+          print("DEBUG: dropping $key");
+          copy.remove(key);
+        }
+      }
+
+      migrated.add(copy);
+    }
+  });
+
+  // replace the old table with the migrated one
+  if (migrated.isNotEmpty) {
+    // Delete table
+    await db.execute("drop table ${struct.table}");
+
+    // Recreate table
+    await createTable(db, struct);
+    await Future.forEach(migrated, (Map<String, Object?> copy) async {
+      await db.insert(struct.table, copy);
+    });
+
+    print("INFO: Database migrated");
+  }
+}

refilc/lib/database/query.dart

@@ -0,0 +1,329 @@
+import 'dart:convert';
+import 'package:refilc/api/providers/database_provider.dart';
+import 'package:refilc/models/self_note.dart';
+import 'package:refilc/models/subject_lesson_count.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/models/week.dart';
+// ignore: depend_on_referenced_packages
+import 'package:sqflite_common/sqlite_api.dart';
+
+// Models
+import 'package:refilc/models/settings.dart';
+import 'package:refilc/api/providers/user_provider.dart';
+import 'package:refilc_kreta_api/models/grade.dart';
+import 'package:refilc_kreta_api/models/lesson.dart';
+import 'package:refilc_kreta_api/models/exam.dart';
+import 'package:refilc_kreta_api/models/homework.dart';
+import 'package:refilc_kreta_api/models/message.dart';
+import 'package:refilc_kreta_api/models/note.dart';
+import 'package:refilc_kreta_api/models/event.dart';
+import 'package:refilc_kreta_api/models/absence.dart';
+import 'package:refilc_kreta_api/models/group_average.dart';
+
+class DatabaseQuery {
+  DatabaseQuery({required this.db});
+
+  final Database db;
+
+  Future<SettingsProvider> getSettings(DatabaseProvider database) async {
+    Map settingsMap = (await db.query("settings")).elementAt(0);
+    SettingsProvider settings =
+        SettingsProvider.fromMap(settingsMap, database: database);
+    return settings;
+  }
+
+  Future<UserProvider> getUsers(SettingsProvider settings) async {
+    var userProvider = UserProvider(settings: settings);
+    List<Map> usersMap = await db.query("users");
+    for (var user in usersMap) {
+      userProvider.addUser(User.fromMap(user));
+    }
+    if (userProvider
+        .getUsers()
+        .map((e) => e.id)
+        .contains(settings.lastAccountId)) {
+      userProvider.setUser(settings.lastAccountId);
+    } else {
+      if (usersMap.isNotEmpty) {
+        userProvider.setUser(userProvider.getUsers().first.id);
+        settings.update(lastAccountId: userProvider.id);
+      }
+    }
+    return userProvider;
+  }
+}
+
+class UserDatabaseQuery {
+  UserDatabaseQuery({required this.db});
+
+  final Database db;
+
+  Future<List<Grade>> getGrades({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? gradesJson = userData.elementAt(0)["grades"] as String?;
+    if (gradesJson == null) return [];
+    List<Grade> grades =
+        (jsonDecode(gradesJson) as List).map((e) => Grade.fromJson(e)).toList();
+    return grades;
+  }
+
+  Future<Map<Week, List<Lesson>>> getLessons({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? lessonsJson = userData.elementAt(0)["timetable"] as String?;
+    if (lessonsJson == null) return {};
+    if (jsonDecode(lessonsJson) is List) return {};
+    Map<Week, List<Lesson>> lessons =
+        (jsonDecode(lessonsJson) as Map).cast<String, List>().map((key, value) {
+      return MapEntry(
+          Week.fromId(int.parse(key)),
+          value
+              .cast<Map<String, Object?>>()
+              .map((e) => Lesson.fromJson(e))
+              .toList());
+    }).cast();
+    return lessons;
+  }
+
+  Future<List<Exam>> getExams({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? examsJson = userData.elementAt(0)["exams"] as String?;
+    if (examsJson == null) return [];
+    List<Exam> exams =
+        (jsonDecode(examsJson) as List).map((e) => Exam.fromJson(e)).toList();
+    return exams;
+  }
+
+  Future<List<Homework>> getHomework({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? homeworkJson = userData.elementAt(0)["homework"] as String?;
+    if (homeworkJson == null) return [];
+    List<Homework> homework = (jsonDecode(homeworkJson) as List)
+        .map((e) => Homework.fromJson(e))
+        .toList();
+    return homework;
+  }
+
+  Future<List<Message>> getMessages({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? messagesJson = userData.elementAt(0)["messages"] as String?;
+    if (messagesJson == null) return [];
+    List<Message> messages = (jsonDecode(messagesJson) as List)
+        .map((e) => Message.fromJson(e))
+        .toList();
+    return messages;
+  }
+
+  Future<List<SendRecipient>> getRecipients({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? recipientsJson = userData.elementAt(0)["recipients"] as String?;
+    if (recipientsJson == null) return [];
+    List<SendRecipient> recipients = (jsonDecode(recipientsJson) as List)
+        .map((e) => SendRecipient.fromJson(
+            e,
+            SendRecipientType.fromJson(e != null
+                ? e['tipus']
+                : {
+                    'azonosito': '',
+                    'kod': '',
+                    'leiras': '',
+                    'nev': '',
+                    'rovidNev': ''
+                  })))
+        .toList();
+    return recipients;
+  }
+
+  Future<List<Note>> getNotes({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? notesJson = userData.elementAt(0)["notes"] as String?;
+    if (notesJson == null) return [];
+    List<Note> notes =
+        (jsonDecode(notesJson) as List).map((e) => Note.fromJson(e)).toList();
+    return notes;
+  }
+
+  Future<List<Event>> getEvents({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? eventsJson = userData.elementAt(0)["events"] as String?;
+    if (eventsJson == null) return [];
+    List<Event> events =
+        (jsonDecode(eventsJson) as List).map((e) => Event.fromJson(e)).toList();
+    return events;
+  }
+
+  Future<List<Absence>> getAbsences({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? absencesJson = userData.elementAt(0)["absences"] as String?;
+    if (absencesJson == null) return [];
+    List<Absence> absences = (jsonDecode(absencesJson) as List)
+        .map((e) => Absence.fromJson(e))
+        .toList();
+    return absences;
+  }
+
+  Future<List<GroupAverage>> getGroupAverages({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? groupAveragesJson =
+        userData.elementAt(0)["group_averages"] as String?;
+    if (groupAveragesJson == null) return [];
+    List<GroupAverage> groupAverages = (jsonDecode(groupAveragesJson) as List)
+        .map((e) => GroupAverage.fromJson(e))
+        .toList();
+    return groupAverages;
+  }
+
+  Future<SubjectLessonCount> getSubjectLessonCount(
+      {required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return SubjectLessonCount.fromMap({});
+    String? lessonCountJson =
+        userData.elementAt(0)["subject_lesson_count"] as String?;
+    if (lessonCountJson == null) return SubjectLessonCount.fromMap({});
+    SubjectLessonCount lessonCount =
+        SubjectLessonCount.fromMap(jsonDecode(lessonCountJson) as Map);
+    return lessonCount;
+  }
+
+  Future<DateTime> lastSeenGrade({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return DateTime(0);
+    int? lastSeenDate = userData.elementAt(0)["last_seen_grade"] as int?;
+    if (lastSeenDate == null) return DateTime(0);
+    DateTime lastSeen = DateTime.fromMillisecondsSinceEpoch(lastSeenDate);
+    return lastSeen;
+  }
+
+  // renamed things
+  Future<Map<String, String>> renamedSubjects({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? renamedSubjectsJson =
+        userData.elementAt(0)["renamed_subjects"] as String?;
+    if (renamedSubjectsJson == null) return {};
+    return (jsonDecode(renamedSubjectsJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  Future<Map<String, String>> renamedTeachers({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? renamedTeachersJson =
+        userData.elementAt(0)["renamed_teachers"] as String?;
+    if (renamedTeachersJson == null) return {};
+    return (jsonDecode(renamedTeachersJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  // goal planner
+  Future<Map<String, String>> subjectGoalPlans({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? goalPlansJson = userData.elementAt(0)["goal_plans"] as String?;
+    if (goalPlansJson == null) return {};
+    return (jsonDecode(goalPlansJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  Future<Map<String, String>> subjectGoalAverages(
+      {required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? goalAvgsJson = userData.elementAt(0)["goal_averages"] as String?;
+    if (goalAvgsJson == null) return {};
+    return (jsonDecode(goalAvgsJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  Future<Map<String, String>> subjectGoalBefores(
+      {required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? goalBeforesJson = userData.elementAt(0)["goal_befores"] as String?;
+    if (goalBeforesJson == null) return {};
+    return (jsonDecode(goalBeforesJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  Future<Map<String, String>> subjectGoalPinDates(
+      {required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? goalPinDatesJson =
+        userData.elementAt(0)["goal_pin_dates"] as String?;
+    if (goalPinDatesJson == null) return {};
+    return (jsonDecode(goalPinDatesJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  // get todo items and notes
+  Future<Map<String, bool>> toDoItems({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? toDoItemsJson = userData.elementAt(0)["todo_items"] as String?;
+    if (toDoItemsJson == null) return {};
+    return (jsonDecode(toDoItemsJson) as Map).map((key, value) =>
+        MapEntry(key.toString(), value.toString().toLowerCase() == 'true'));
+  }
+
+  Future<List<SelfNote>> getSelfNotes({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return [];
+    String? selfNotesJson = userData.elementAt(0)["self_notes"] as String?;
+    if (selfNotesJson == null) return [];
+    List<SelfNote> selfNotes = (jsonDecode(selfNotesJson) as List)
+        .map((e) => SelfNote.fromJson(e))
+        .toList();
+    return selfNotes;
+  }
+
+  // v5
+  Future<Map<String, String>> getRoundings({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? roundingsJson = userData.elementAt(0)["roundings"] as String?;
+    if (roundingsJson == null) return {};
+    return (jsonDecode(roundingsJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+
+  Future<Map<String, String>> getGradeRarities({required String userId}) async {
+    List<Map> userData =
+        await db.query("user_data", where: "id = ?", whereArgs: [userId]);
+    if (userData.isEmpty) return {};
+    String? raritiesJson = userData.elementAt(0)["grade_rarities"] as String?;
+    if (raritiesJson == null) return {};
+    return (jsonDecode(raritiesJson) as Map)
+        .map((key, value) => MapEntry(key.toString(), value.toString()));
+  }
+}

refilc/lib/database/store.dart

@@ -0,0 +1,211 @@
+import 'dart:convert';
+import 'package:refilc/models/self_note.dart';
+import 'package:refilc/models/subject_lesson_count.dart';
+import 'package:refilc_kreta_api/models/week.dart';
+// ignore: depend_on_referenced_packages
+import 'package:sqflite_common/sqlite_api.dart';
+
+// Models
+import 'package:refilc/models/settings.dart';
+import 'package:refilc/models/user.dart';
+import 'package:refilc_kreta_api/models/grade.dart';
+import 'package:refilc_kreta_api/models/lesson.dart';
+import 'package:refilc_kreta_api/models/exam.dart';
+import 'package:refilc_kreta_api/models/homework.dart';
+import 'package:refilc_kreta_api/models/message.dart';
+import 'package:refilc_kreta_api/models/note.dart';
+import 'package:refilc_kreta_api/models/event.dart';
+import 'package:refilc_kreta_api/models/absence.dart';
+import 'package:refilc_kreta_api/models/group_average.dart';
+
+class DatabaseStore {
+  DatabaseStore({required this.db});
+
+  final Database db;
+
+  Future<void> storeSettings(SettingsProvider settings) async {
+    await db.update("settings", settings.toMap());
+  }
+
+  Future<void> storeUser(User user) async {
+    List userRes =
+        await db.query("users", where: "id = ?", whereArgs: [user.id]);
+    if (userRes.isNotEmpty) {
+      await db
+          .update("users", user.toMap(), where: "id = ?", whereArgs: [user.id]);
+    } else {
+      await db.insert("users", user.toMap());
+      await db.insert("user_data", {"id": user.id});
+    }
+  }
+
+  Future<void> removeUser(String userId) async {
+    await db.delete("users", where: "id = ?", whereArgs: [userId]);
+    await db.delete("user_data", where: "id = ?", whereArgs: [userId]);
+  }
+}
+
+class UserDatabaseStore {
+  UserDatabaseStore({required this.db});
+
+  final Database db;
+
+  Future<void> storeGrades(List<Grade> grades, {required String userId}) async {
+    String gradesJson = jsonEncode(grades.map((e) => e.json).toList());
+    await db.update("user_data", {"grades": gradesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeLessons(Map<Week, List<Lesson>?> lessons,
+      {required String userId}) async {
+    final map = lessons.map<String, List<Map<String, Object?>>>(
+      (k, v) => MapEntry(k.id.toString(),
+          v!.where((e) => e.json != null).map((e) => e.json!).toList().cast()),
+    );
+    String lessonsJson = jsonEncode(map);
+    await db.update("user_data", {"timetable": lessonsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeExams(List<Exam> exams, {required String userId}) async {
+    String examsJson = jsonEncode(exams.map((e) => e.json).toList());
+    await db.update("user_data", {"exams": examsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeHomework(List<Homework> homework,
+      {required String userId}) async {
+    String homeworkJson = jsonEncode(homework.map((e) => e.json).toList());
+    await db.update("user_data", {"homework": homeworkJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeMessages(List<Message> messages,
+      {required String userId}) async {
+    String messagesJson = jsonEncode(messages.map((e) => e.json).toList());
+    await db.update("user_data", {"messages": messagesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeRecipients(List<SendRecipient> recipients,
+      {required String userId}) async {
+    String recipientsJson = jsonEncode(recipients.map((e) => e.json).toList());
+    await db.update("user_data", {"recipients": recipientsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeNotes(List<Note> notes, {required String userId}) async {
+    String notesJson = jsonEncode(notes.map((e) => e.json).toList());
+    await db.update("user_data", {"notes": notesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeEvents(List<Event> events, {required String userId}) async {
+    String eventsJson = jsonEncode(events.map((e) => e.json).toList());
+    await db.update("user_data", {"events": eventsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeAbsences(List<Absence> absences,
+      {required String userId}) async {
+    String absencesJson = jsonEncode(absences.map((e) => e.json).toList());
+    await db.update("user_data", {"absences": absencesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeGroupAverages(List<GroupAverage> groupAverages,
+      {required String userId}) async {
+    String groupAveragesJson =
+        jsonEncode(groupAverages.map((e) => e.json).toList());
+    await db.update("user_data", {"group_averages": groupAveragesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeSubjectLessonCount(SubjectLessonCount lessonCount,
+      {required String userId}) async {
+    String lessonCountJson = jsonEncode(lessonCount.toMap());
+    await db.update("user_data", {"subject_lesson_count": lessonCountJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeLastSeenGrade(DateTime date,
+      {required String userId}) async {
+    int lastSeenDate = date.millisecondsSinceEpoch;
+    await db.update("user_data", {"last_seen_grade": lastSeenDate},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  // renamed things
+  Future<void> storeRenamedSubjects(Map<String, String> subjects,
+      {required String userId}) async {
+    String renamedSubjectsJson = jsonEncode(subjects);
+    await db.update("user_data", {"renamed_subjects": renamedSubjectsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeRenamedTeachers(Map<String, String> teachers,
+      {required String userId}) async {
+    String renamedTeachersJson = jsonEncode(teachers);
+    await db.update("user_data", {"renamed_teachers": renamedTeachersJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  // goal planner
+  Future<void> storeSubjectGoalPlans(Map<String, String> plans,
+      {required String userId}) async {
+    String goalPlansJson = jsonEncode(plans);
+    await db.update("user_data", {"goal_plans": goalPlansJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeSubjectGoalAverages(Map<String, String> avgs,
+      {required String userId}) async {
+    String goalAvgsJson = jsonEncode(avgs);
+    await db.update("user_data", {"goal_averages": goalAvgsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeSubjectGoalBefores(Map<String, String> befores,
+      {required String userId}) async {
+    String goalBeforesJson = jsonEncode(befores);
+    await db.update("user_data", {"goal_befores": goalBeforesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeSubjectGoalPinDates(Map<String, String> dates,
+      {required String userId}) async {
+    String goalPinDatesJson = jsonEncode(dates);
+    await db.update("user_data", {"goal_pin_dates": goalPinDatesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  // todo and notes
+  Future<void> storeToDoItem(Map<String, bool> items,
+      {required String userId}) async {
+    String toDoItemsJson = jsonEncode(items);
+    await db.update("user_data", {"todo_items": toDoItemsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeSelfNotes(List<SelfNote> selfNotes,
+      {required String userId}) async {
+    String selfNotesJson = jsonEncode(selfNotes.map((e) => e.json).toList());
+    await db.update("user_data", {"self_notes": selfNotesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  // v5
+  Future<void> storeRoundings(Map<String, String> roundings,
+      {required String userId}) async {
+    String roundingsJson = jsonEncode(roundings);
+    await db.update("user_data", {"roundings": roundingsJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+
+  Future<void> storeGradeRarities(Map<String, String> rarities,
+      {required String userId}) async {
+    String raritiesJson = jsonEncode(rarities);
+    await db.update("user_data", {"grade_rarities": raritiesJson},
+        where: "id = ?", whereArgs: [userId]);
+  }
+}

refilc/lib/database/struct.dart

@@ -0,0 +1,30 @@
+class DatabaseStruct {
+  final String table;
+  final Map<String, dynamic> struct;
+
+  const DatabaseStruct(this.table, this.struct);
+
+  String _toDBfield(String name, dynamic type) {
+    String typeName = "";
+
+    switch (type.runtimeType) {
+      case int:
+        typeName = "integer";
+        break;
+      case String:
+        typeName = "text";
+        break;
+    }
+
+    return "$name ${typeName.toUpperCase()} ${name == 'id' ? 'NOT NULL' : ''}";
+  }
+
+  @override
+  String toString() {
+    List<String> columns = [];
+    struct.forEach((key, value) {
+      columns.add(_toDBfield(key, value));
+    });
+    return columns.join(",");
+  }
+}