feat: people page/sheet/detail (#20309)

mobile/lib/infrastructure/repositories/asset_face.repository.dart

@@ -1,30 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:immich_mobile/domain/models/asset_face.model.dart';
-import 'package:immich_mobile/infrastructure/entities/asset_face.entity.drift.dart';
-import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
-
-class DriftAssetFaceRepository extends DriftDatabaseRepository {
-  final Drift _db;
-  const DriftAssetFaceRepository(this._db) : super(_db);
-
-  Future<List<AssetFace>> getAll() {
-    return _db.assetFaceEntity.select().map((assetFace) => assetFace.toDto()).get();
-  }
-}
-
-extension on AssetFaceEntityData {
-  AssetFace toDto() {
-    return AssetFace(
-      id: id,
-      assetId: assetId,
-      personId: personId,
-      imageWidth: imageWidth,
-      imageHeight: imageHeight,
-      boundingBoxX1: boundingBoxX1,
-      boundingBoxY1: boundingBoxY1,
-      boundingBoxX2: boundingBoxX2,
-      boundingBoxY2: boundingBoxY2,
-      sourceType: sourceType,
-    );
-  }
-}

mobile/lib/infrastructure/repositories/people.repository.dart

@@ -0,0 +1,67 @@
+import 'package:drift/drift.dart';
+import 'package:immich_mobile/domain/models/person.model.dart';
+import 'package:immich_mobile/infrastructure/entities/person.entity.drift.dart';
+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
+
+class DriftPeopleRepository extends DriftDatabaseRepository {
+  final Drift _db;
+  const DriftPeopleRepository(this._db) : super(_db);
+
+  Future<List<DriftPerson>> getAssetPeople(String assetId) async {
+    final query = _db.select(_db.assetFaceEntity).join([
+      innerJoin(_db.personEntity, _db.personEntity.id.equalsExp(_db.assetFaceEntity.personId)),
+    ])..where(_db.assetFaceEntity.assetId.equals(assetId) & _db.personEntity.isHidden.equals(false));
+
+    return query.map((row) {
+      final person = row.readTable(_db.personEntity);
+      return person.toDto();
+    }).get();
+  }
+
+  Future<List<DriftPerson>> getAllPeople() async {
+    final query =
+        _db.select(_db.personEntity).join([
+            leftOuterJoin(_db.assetFaceEntity, _db.assetFaceEntity.personId.equalsExp(_db.personEntity.id)),
+          ])
+          ..where(_db.personEntity.isHidden.equals(false))
+          ..groupBy([_db.personEntity.id])
+          ..orderBy([
+            OrderingTerm(expression: _db.personEntity.name.equals('').not(), mode: OrderingMode.desc),
+            OrderingTerm(expression: _db.assetFaceEntity.id.count(), mode: OrderingMode.desc),
+          ]);
+
+    return query.map((row) {
+      final person = row.readTable(_db.personEntity);
+      return person.toDto();
+    }).get();
+  }
+
+  Future<int> updateName(String personId, String name) {
+    final query = _db.update(_db.personEntity)..where((row) => row.id.equals(personId));
+
+    return query.write(PersonEntityCompanion(name: Value(name), updatedAt: Value(DateTime.now())));
+  }
+
+  Future<int> updateBirthday(String personId, DateTime birthday) {
+    final query = _db.update(_db.personEntity)..where((row) => row.id.equals(personId));
+
+    return query.write(PersonEntityCompanion(birthDate: Value(birthday), updatedAt: Value(DateTime.now())));
+  }
+}
+
+extension on PersonEntityData {
+  DriftPerson toDto() {
+    return DriftPerson(
+      id: id,
+      createdAt: createdAt,
+      updatedAt: updatedAt,
+      ownerId: ownerId,
+      name: name,
+      faceAssetId: faceAssetId,
+      isFavorite: isFavorite,
+      isHidden: isHidden,
+      color: color,
+      birthDate: birthDate,
+    );
+  }
+}

mobile/lib/infrastructure/repositories/person.repository.dart

@@ -1,34 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:immich_mobile/domain/models/person.model.dart';
-import 'package:immich_mobile/infrastructure/entities/person.entity.drift.dart';
-import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
-
-class DriftPersonRepository extends DriftDatabaseRepository {
-  final Drift _db;
-  const DriftPersonRepository(this._db) : super(_db);
-
-  Future<List<Person>> getAll(String userId) {
-    final query = _db.personEntity.select()..where((e) => e.ownerId.equals(userId));
-
-    return query.map((person) {
-      return person.toDto();
-    }).get();
-  }
-}
-
-extension on PersonEntityData {
-  Person toDto() {
-    return Person(
-      id: id,
-      createdAt: createdAt,
-      updatedAt: updatedAt,
-      ownerId: ownerId,
-      name: name,
-      faceAssetId: faceAssetId,
-      isFavorite: isFavorite,
-      isHidden: isHidden,
-      color: color,
-      birthDate: birthDate,
-    );
-  }
-}

mobile/lib/infrastructure/repositories/timeline.repository.dart

@@ -292,6 +292,11 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     assetSource: (offset, count) => _getPlaceBucketAssets(place, offset: offset, count: count),
   );
 
+  TimelineQuery person(String userId, String personId, GroupAssetsBy groupBy) => (
+    bucketSource: () => _watchPersonBucket(userId, personId, groupBy: groupBy),
+    assetSource: (offset, count) => _getPersonBucketAssets(userId, personId, offset: offset, count: count),
+  );
+
   Stream<List<Bucket>> _watchPlaceBucket(String place, {GroupAssetsBy groupBy = GroupAssetsBy.day}) {
     if (groupBy == GroupAssetsBy.none) {
       // TODO: implement GroupAssetBy for place
@@ -344,6 +349,84 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     return query.map((row) => row.readTable(_db.remoteAssetEntity).toDto()).get();
   }
 
+  Stream<List<Bucket>> _watchPersonBucket(String userId, String personId, {GroupAssetsBy groupBy = GroupAssetsBy.day}) {
+    if (groupBy == GroupAssetsBy.none) {
+      final query = _db.remoteAssetEntity.selectOnly()
+        ..addColumns([_db.remoteAssetEntity.id.count()])
+        ..join([
+          innerJoin(
+            _db.assetFaceEntity,
+            _db.assetFaceEntity.assetId.equalsExp(_db.remoteAssetEntity.id),
+            useColumns: false,
+          ),
+        ])
+        ..where(
+          _db.remoteAssetEntity.deletedAt.isNull() &
+              _db.remoteAssetEntity.ownerId.equals(userId) &
+              _db.remoteAssetEntity.visibility.equalsValue(AssetVisibility.timeline) &
+              _db.assetFaceEntity.personId.equals(personId),
+        );
+
+      return query.map((row) {
+        final count = row.read(_db.remoteAssetEntity.id.count())!;
+        return _generateBuckets(count);
+      }).watchSingle();
+    }
+
+    final assetCountExp = _db.remoteAssetEntity.id.count();
+    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
+
+    final query = _db.remoteAssetEntity.selectOnly()
+      ..addColumns([assetCountExp, dateExp])
+      ..join([
+        innerJoin(
+          _db.assetFaceEntity,
+          _db.assetFaceEntity.assetId.equalsExp(_db.remoteAssetEntity.id),
+          useColumns: false,
+        ),
+      ])
+      ..where(
+        _db.remoteAssetEntity.deletedAt.isNull() &
+            _db.remoteAssetEntity.ownerId.equals(userId) &
+            _db.remoteAssetEntity.visibility.equalsValue(AssetVisibility.timeline) &
+            _db.assetFaceEntity.personId.equals(personId),
+      )
+      ..groupBy([dateExp])
+      ..orderBy([OrderingTerm.desc(dateExp)]);
+
+    return query.map((row) {
+      final timeline = row.read(dateExp)!.dateFmt(groupBy);
+      final assetCount = row.read(assetCountExp)!;
+      return TimeBucket(date: timeline, assetCount: assetCount);
+    }).watch();
+  }
+
+  Future<List<BaseAsset>> _getPersonBucketAssets(
+    String userId,
+    String personId, {
+    required int offset,
+    required int count,
+  }) {
+    final query =
+        _db.remoteAssetEntity.select().join([
+            innerJoin(
+              _db.assetFaceEntity,
+              _db.assetFaceEntity.assetId.equalsExp(_db.remoteAssetEntity.id),
+              useColumns: false,
+            ),
+          ])
+          ..where(
+            _db.remoteAssetEntity.deletedAt.isNull() &
+                _db.remoteAssetEntity.ownerId.equals(userId) &
+                _db.remoteAssetEntity.visibility.equalsValue(AssetVisibility.timeline) &
+                _db.assetFaceEntity.personId.equals(personId),
+          )
+          ..orderBy([OrderingTerm.desc(_db.remoteAssetEntity.createdAt)])
+          ..limit(count, offset: offset);
+
+    return query.map((row) => row.readTable(_db.remoteAssetEntity).toDto()).get();
+  }
+
   TimelineQuery _remoteQueryBuilder({
     required Expression<bool> Function($RemoteAssetEntityTable row) filter,
     GroupAssetsBy groupBy = GroupAssetsBy.day,