🚀

mobile-v2/lib/domain/models/log.model.dart

@@ -0,0 +1,59 @@
+import 'package:logging/logging.dart';
+
+/// Log levels according to dart logging [Level]
+enum LogLevel {
+  all,
+  finest,
+  finer,
+  fine,
+  config,
+  info,
+  warning,
+  severe,
+  shout,
+  off,
+}
+
+extension LevelExtension on Level {
+  LogLevel toLogLevel() =>
+      LogLevel.values.elementAtOrNull(Level.LEVELS.indexOf(this)) ??
+      LogLevel.info;
+}
+
+class LogMessage {
+  final int id;
+  final String content;
+  final LogLevel level;
+  final DateTime createdAt;
+  final String? logger;
+  final String? error;
+  final String? stack;
+
+  const LogMessage({
+    required this.id,
+    required this.content,
+    required this.level,
+    required this.createdAt,
+    this.logger,
+    this.error,
+    this.stack,
+  });
+
+  @override
+  bool operator ==(covariant LogMessage other) {
+    if (identical(this, other)) return true;
+
+    return other.hashCode == hashCode;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        content.hashCode ^
+        level.hashCode ^
+        createdAt.hashCode ^
+        logger.hashCode ^
+        error.hashCode ^
+        stack.hashCode;
+  }
+}

mobile-v2/lib/domain/models/store.model.dart

@@ -0,0 +1,70 @@
+/// Key for each possible value in the `Store`.
+/// Defines the data type for each value
+enum StoreKey<T> {
+  // Server endpoint related stores
+  accessToken<String>(0, type: String),
+  serverEndpoint<String>(1, type: String),
+  ;
+
+  const StoreKey(this.id, {required this.type});
+  final int id;
+  final Type type;
+}
+
+class StoreValue {
+  final int id;
+  final int? intValue;
+  final String? stringValue;
+
+  const StoreValue({required this.id, this.intValue, this.stringValue});
+
+  @override
+  bool operator ==(covariant StoreValue other) {
+    if (identical(this, other)) return true;
+
+    return other.hashCode == hashCode;
+  }
+
+  @override
+  int get hashCode => id.hashCode ^ intValue.hashCode ^ stringValue.hashCode;
+
+  T? extract<T>(Type type) {
+    switch (type) {
+      case const (int):
+        return intValue as T?;
+      case const (bool):
+        return intValue == null ? null : (intValue! == 1) as T;
+      case const (DateTime):
+        return intValue == null
+            ? null
+            : DateTime.fromMicrosecondsSinceEpoch(intValue!) as T;
+      case const (String):
+        return stringValue as T?;
+      default:
+        throw UnsupportedError("Unknown Store Key type");
+    }
+  }
+
+  static StoreValue of<T>(StoreKey<T> key, T? value) {
+    int? i;
+    String? s;
+
+    switch (key.type) {
+      case const (int):
+        i = value as int?;
+        break;
+      case const (bool):
+        i = value == null ? null : (value == true ? 1 : 0);
+        break;
+      case const (DateTime):
+        i = value == null ? null : (value as DateTime).microsecondsSinceEpoch;
+        break;
+      case const (String):
+        s = value as String?;
+        break;
+      default:
+        throw UnsupportedError("Unknown Store Key type");
+    }
+    return StoreValue(id: key.id, intValue: i, stringValue: s);
+  }
+}