Merge pull request #453 from wger-project/feat/data-persistence

feat(drift-database): Shifted from shared prefs to drift for Exercises

Author: rolandgeider

flatpak/scripts/flatpak_shared.dart

@@ -44,9 +44,8 @@ class Icon {
     _fileExtension = path.split('.').last;
   }
 
-  String getFilename(String appId) => (type == _symbolicType)
-      ? '$appId-symbolic.$_fileExtension'
-      : '$appId.$_fileExtension';
+  String getFilename(String appId) =>
+      (type == _symbolicType) ? '$appId-symbolic.$_fileExtension' : '$appId.$_fileExtension';
 }
 
 class GithubReleases {
@@ -75,8 +74,7 @@ class GithubReleases {
     final releaseJsonContent = (await http.get(Uri(
             scheme: 'https',
             host: 'api.github.com',
-            path:
-                '/repos/$githubReleaseOrganization/$githubReleaseProject/releases')))
+            path: '/repos/$githubReleaseOrganization/$githubReleaseProject/releases')))
         .body;
     final decodedJson = jsonDecode(releaseJsonContent) as List;
 
@@ -87,23 +85,19 @@ class GithubReleases {
     await Future.forEach<dynamic>(decodedJson, (dynamic releaseDynamic) async {
       final releaseMap = releaseDynamic as Map;
 
-      final releaseDateAndTime =
-          DateTime.parse(releaseMap['published_at'] as String);
-      final releaseDateString =
-          releaseDateAndTime.toIso8601String().split('T').first;
+      final releaseDateAndTime = DateTime.parse(releaseMap['published_at'] as String);
+      final releaseDateString = releaseDateAndTime.toIso8601String().split('T').first;
 
       if (latestReleaseAssetDate == null ||
           (latestReleaseAssetDate?.compareTo(releaseDateAndTime) == -1)) {
-        final assets =
-            await _parseGithubReleaseAssets(releaseMap['assets'] as List);
+        final assets = await _parseGithubReleaseAssets(releaseMap['assets'] as List);
         if (assets != null) {
           _latestReleaseAssets = assets;
           latestReleaseAssetDate = releaseDateAndTime;
         }
       }
 
-      releases.add(Release(
-          version: releaseMap['name'] as String, date: releaseDateString));
+      releases.add(Release(version: releaseMap['name'] as String, date: releaseDateString));
     });
 
     if (releases.isNotEmpty || canBeEmpty) {
@@ -124,8 +118,7 @@ class GithubReleases {
       final downloadUrl = amMap['browser_download_url'] as String;
       final filename = amMap['name'] as String;
       final fileExtension = filename.substring(filename.indexOf('.') + 1);
-      final filenameWithoutExtension =
-          filename.substring(0, filename.indexOf('.'));
+      final filenameWithoutExtension = filename.substring(0, filename.indexOf('.'));
 
       final arch = filenameWithoutExtension.endsWith('aarch64')
           ? CPUArchitecture.aarch64
@@ -221,8 +214,7 @@ class FlatpakMeta {
       : _localReleases = localReleases,
         _localReleaseAssets = localReleaseAssets {
     if (githubReleaseOrganization != null && githubReleaseProject != null) {
-      _githubReleases =
-          GithubReleases(githubReleaseOrganization!, githubReleaseProject!);
+      _githubReleases = GithubReleases(githubReleaseOrganization!, githubReleaseProject!);
     }
   }
 
@@ -231,20 +223,17 @@ class FlatpakMeta {
     final releases = List<Release>.empty(growable: true);
     if (addedTodaysVersion != null) {
       releases.add(Release(
-          version: addedTodaysVersion,
-          date: DateTime.now().toIso8601String().split("T").first));
+          version: addedTodaysVersion, date: DateTime.now().toIso8601String().split("T").first));
     }
     if (fetchReleasesFromGithub) {
       if (_githubReleases == null) {
         throw Exception(
             'Metadata must include Github repository info if fetching releases from Github.');
       }
-      releases.addAll(
-          await _githubReleases!.getReleases(addedTodaysVersion != null));
+      releases.addAll(await _githubReleases!.getReleases(addedTodaysVersion != null));
     } else {
       if (_localReleases == null && addedTodaysVersion == null) {
-        throw Exception(
-            'Metadata must include releases if not fetching releases from Github.');
+        throw Exception('Metadata must include releases if not fetching releases from Github.');
       }
       if (_localReleases?.isNotEmpty ?? false) {
         releases.addAll(_localReleases!);
@@ -253,8 +242,7 @@ class FlatpakMeta {
     return releases;
   }
 
-  Future<List<ReleaseAsset>?> getLatestReleaseAssets(
-      bool fetchReleasesFromGithub) async {
+  Future<List<ReleaseAsset>?> getLatestReleaseAssets(bool fetchReleasesFromGithub) async {
     if (fetchReleasesFromGithub) {
       if (_githubReleases == null) {
         throw Exception(
@@ -263,8 +251,7 @@ class FlatpakMeta {
       return await _githubReleases!.getLatestReleaseAssets();
     } else {
       if (_localReleases == null) {
-        throw Exception(
-            'Metadata must include releases if not fetching releases from Github.');
+        throw Exception('Metadata must include releases if not fetching releases from Github.');
       }
       return _localReleaseAssets;
     }
@@ -276,24 +263,20 @@ class FlatpakMeta {
       return FlatpakMeta(
           appId: json['appId'] as String,
           lowercaseAppName: json['lowercaseAppName'] as String,
-          githubReleaseOrganization:
-              json['githubReleaseOrganization'] as String?,
+          githubReleaseOrganization: json['githubReleaseOrganization'] as String?,
           githubReleaseProject: json['githubReleaseProject'] as String?,
           localReleases: skipLocalReleases
               ? null
               : (json['localReleases'] as List?)?.map((dynamic r) {
                   final rMap = r as Map;
-                  return Release(
-                      version: rMap['version'] as String,
-                      date: rMap['date'] as String);
+                  return Release(version: rMap['version'] as String, date: rMap['date'] as String);
                 }).toList(),
           localReleaseAssets: skipLocalReleases
               ? null
               : (json['localReleaseAssets'] as List?)?.map((dynamic ra) {
                   final raMap = ra as Map;
                   final archString = raMap['arch'] as String;
-                  final arch = (archString ==
-                          CPUArchitecture.x86_64.flatpakArchCode)
+                  final arch = (archString == CPUArchitecture.x86_64.flatpakArchCode)
                       ? CPUArchitecture.x86_64
                       : (archString == CPUArchitecture.aarch64.flatpakArchCode)
                           ? CPUArchitecture.aarch64
@@ -302,11 +285,10 @@ class FlatpakMeta {
                     throw Exception(
                         'Architecture must be either "${CPUArchitecture.x86_64.flatpakArchCode}" or "${CPUArchitecture.aarch64.flatpakArchCode}"');
                   }
-                  final tarballFile = File(
-                      '${jsonFile.parent.path}/${raMap['tarballPath'] as String}');
+                  final tarballFile =
+                      File('${jsonFile.parent.path}/${raMap['tarballPath'] as String}');
                   final tarballPath = tarballFile.absolute.path;
-                  final preShasum =
-                      Process.runSync('shasum', ['-a', '256', tarballPath]);
+                  final preShasum = Process.runSync('shasum', ['-a', '256', tarballPath]);
                   final shasum = preShasum.stdout.toString().split(' ').first;
                   if (preShasum.exitCode != 0) {
                     throw Exception(preShasum.stderr);
@@ -321,17 +303,14 @@ class FlatpakMeta {
           appStreamPath: json['appStreamPath'] as String,
           desktopPath: json['desktopPath'] as String,
           icons: (json['icons'] as Map).entries.map((mapEntry) {
-            return Icon(
-                type: mapEntry.key as String, path: mapEntry.value as String);
+            return Icon(type: mapEntry.key as String, path: mapEntry.value as String);
           }).toList(),
           freedesktopRuntime: json['freedesktopRuntime'] as String,
           buildCommandsAfterUnpack: (json['buildCommandsAfterUnpack'] as List?)
               ?.map((dynamic bc) => bc as String)
               .toList(),
           extraModules: json['extraModules'] as List?,
-          finishArgs: (json['finishArgs'] as List)
-              .map((dynamic fa) => fa as String)
-              .toList());
+          finishArgs: (json['finishArgs'] as List).map((dynamic fa) => fa as String).toList());
     } catch (e) {
       throw Exception('Could not parse JSON file, due to this error:\n$e');
     }

flatpak/scripts/manifest_generator.dart

@@ -26,8 +26,7 @@ void main(List<String> arguments) async {
         'You must run this script with a metadata file argument, using the --meta flag.');
   }
   if (arguments.length == metaIndex + 1) {
-    throw Exception(
-        'The --meta flag must be followed by the path to the metadata file.');
+    throw Exception('The --meta flag must be followed by the path to the metadata file.');
   }
 
   final metaFile = File(arguments[metaIndex + 1]);
@@ -37,23 +36,19 @@ void main(List<String> arguments) async {
 
   final fetchFromGithub = arguments.contains('--github');
 
-  final meta =
-      FlatpakMeta.fromJson(metaFile, skipLocalReleases: fetchFromGithub);
+  final meta = FlatpakMeta.fromJson(metaFile, skipLocalReleases: fetchFromGithub);
 
-  final outputDir =
-      Directory('${Directory.current.path}/flatpak_generator_exports');
+  final outputDir = Directory('${Directory.current.path}/flatpak_generator_exports');
   outputDir.createSync();
 
   final manifestGenerator = FlatpakManifestGenerator(meta);
-  final manifestContent =
-      await manifestGenerator.generateFlatpakManifest(fetchFromGithub);
+  final manifestContent = await manifestGenerator.generateFlatpakManifest(fetchFromGithub);
   final manifestPath = '${outputDir.path}/${meta.appId}.json';
   final manifestFile = File(manifestPath);
   manifestFile.writeAsStringSync(manifestContent);
   print('Generated $manifestPath');
 
-  final flathubJsonContent =
-      await manifestGenerator.generateFlathubJson(fetchFromGithub);
+  final flathubJsonContent = await manifestGenerator.generateFlathubJson(fetchFromGithub);
   if (flathubJsonContent != null) {
     final flathubJsonPath = '${outputDir.path}/flathub.json';
     final flathubJsonFile = File(flathubJsonPath);
@@ -132,8 +127,7 @@ class FlatpakManifestGenerator {
 
     const encoder = JsonEncoder.withIndent('  ');
 
-    final onlyArchListInput =
-        fetchFromGithub ? _githubArchSupport! : _localArchSupport!;
+    final onlyArchListInput = fetchFromGithub ? _githubArchSupport! : _localArchSupport!;
 
     final onlyArchList = List<String>.empty(growable: true);
     for (final e in onlyArchListInput.entries) {
@@ -149,8 +143,7 @@ class FlatpakManifestGenerator {
     }
   }
 
-  void _lazyGenerateArchSupportMap(
-      bool fetchFromGithub, List<ReleaseAsset> assets) {
+  void _lazyGenerateArchSupportMap(bool fetchFromGithub, List<ReleaseAsset> assets) {
     if (fetchFromGithub) {
       if (_githubArchSupport == null) {
         _githubArchSupport = <CPUArchitecture, bool>{

integration_test/3_gym_mode.dart

@@ -20,8 +20,8 @@ Widget createGymModeScreen({locale = 'en'}) {
 
   final mockExerciseProvider = MockExercisesProvider();
 
-  when(mockExerciseProvider.findExerciseBaseById(1)).thenReturn(bases[0]); // bench press
-  when(mockExerciseProvider.findExerciseBaseById(6)).thenReturn(bases[5]); // side raises
+  when(mockExerciseProvider.findExerciseById(1)).thenReturn(bases[0]); // bench press
+  when(mockExerciseProvider.findExerciseById(6)).thenReturn(bases[5]); // side raises
   //when(mockExerciseProvider.findExerciseBaseById(2)).thenReturn(bases[1]); // crunches
   //when(mockExerciseProvider.findExerciseBaseById(3)).thenReturn(bases[2]); // dead lift
 

lib/core/locator.dart

@@ -0,0 +1,44 @@
+import 'dart:developer';
+import 'dart:io';
+
+import 'package:drift/native.dart';
+import 'package:get_it/get_it.dart';
+import 'package:wger/database/exercises/exercise_database.dart';
+import 'package:wger/database/ingredients/ingredients_database.dart';
+
+final locator = GetIt.asNewInstance();
+
+class ServiceLocator {
+  factory ServiceLocator() => _singleton;
+
+  ServiceLocator._internal();
+
+  static final ServiceLocator _singleton = ServiceLocator._internal();
+
+  Future<void> _initDB() async {
+    ExerciseDatabase exerciseDB;
+    IngredientDatabase ingredientDB;
+    // final exerciseDB = ExerciseDatabase();
+    // final ingredientDB = IngredientDatabase();
+
+    if (Platform.environment.containsKey('FLUTTER_TEST')) {
+      exerciseDB = ExerciseDatabase.inMemory(NativeDatabase.memory());
+      ingredientDB = IngredientDatabase.inMemory(NativeDatabase.memory());
+    } else {
+      exerciseDB = ExerciseDatabase();
+      ingredientDB = IngredientDatabase();
+    }
+
+    locator.registerSingleton<ExerciseDatabase>(exerciseDB);
+    locator.registerSingleton<IngredientDatabase>(ingredientDB);
+  }
+
+  Future<void> configure() async {
+    try {
+      await _initDB();
+    } catch (e, _) {
+      log(e.toString());
+      rethrow;
+    }
+  }
+}

lib/database/exercises/exercise_database.dart

@@ -0,0 +1,85 @@
+import 'dart:io';
+
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:path/path.dart' as p;
+import 'package:path_provider/path_provider.dart';
+import 'package:wger/database/exercises/type_converters.dart';
+import 'package:wger/models/exercises/category.dart';
+import 'package:wger/models/exercises/equipment.dart';
+import 'package:wger/models/exercises/language.dart';
+import 'package:wger/models/exercises/muscle.dart';
+
+part 'exercise_database.g.dart';
+
+@DataClassName('ExerciseTable')
+class Exercises extends Table {
+  IntColumn get id => integer()();
+
+  TextColumn get data => text()();
+
+  // TextColumn get data => text().map(const ExerciseBaseConverter())();
+
+  DateTimeColumn get lastUpdate => dateTime()();
+
+  /// The date when the exercise was last fetched from the API. While we know
+  /// when the exercise itself was last updated in `lastUpdate`, we can save
+  /// ourselves a lot of requests if we don't check too often
+  DateTimeColumn get lastFetched => dateTime()();
+}
+
+@DataClassName('MuscleTable')
+class Muscles extends Table {
+  IntColumn get id => integer()();
+
+  TextColumn get data => text().map(const MuscleConverter())();
+}
+
+@DataClassName('CategoryTable')
+class Categories extends Table {
+  IntColumn get id => integer()();
+
+  TextColumn get data => text().map(const ExerciseCategoryConverter())();
+}
+
+@DataClassName('LanguagesTable')
+class Languages extends Table {
+  IntColumn get id => integer()();
+
+  TextColumn get data => text().map(const LanguageConverter())();
+}
+
+@DataClassName('EquipmentTable')
+class Equipments extends Table {
+  IntColumn get id => integer()();
+
+  TextColumn get data => text().map(const EquipmentConverter())();
+}
+
+@DriftDatabase(tables: [Exercises, Muscles, Equipments, Categories, Languages])
+class ExerciseDatabase extends _$ExerciseDatabase {
+  ExerciseDatabase() : super(_openConnection());
+
+  // Named constructor for creating in-memory database
+  ExerciseDatabase.inMemory(super.e);
+
+  @override
+  // TODO: implement schemaVersion
+  int get schemaVersion => 1;
+
+  Future<void> deleteEverything() {
+    return transaction(() async {
+      for (final table in allTables) {
+        await delete(table).go();
+      }
+    });
+  }
+}
+
+LazyDatabase _openConnection() {
+  return LazyDatabase(() async {
+    final dbFolder = await getApplicationCacheDirectory();
+    final file = File(p.join(dbFolder.path, 'exercises.sqlite'));
+    return NativeDatabase.createInBackground(file);
+  });
+}