feat(web): timeline bucket for albums (4) (#3604)

* feat: server changes for album timeline

* feat(web): album timeline view

* chore: open api

* chore: remove archive action

* fix: favorite for non-owners

server/src/domain/album/album-response.dto.ts

@@ -13,14 +13,17 @@ export class AlbumResponseDto {
   albumThumbnailAssetId!: string | null;
   shared!: boolean;
   sharedUsers!: UserResponseDto[];
+  hasSharedLink!: boolean;
   assets!: AssetResponseDto[];
   owner!: UserResponseDto;
   @ApiProperty({ type: 'integer' })
   assetCount!: number;
   lastModifiedAssetTimestamp?: Date;
+  startDate?: Date;
+  endDate?: Date;
 }
 
-const _map = (entity: AlbumEntity, withAssets: boolean): AlbumResponseDto => {
+export const mapAlbum = (entity: AlbumEntity, withAssets: boolean): AlbumResponseDto => {
   const sharedUsers: UserResponseDto[] = [];
 
   entity.sharedUsers?.forEach((user) => {
@@ -28,6 +31,11 @@ const _map = (entity: AlbumEntity, withAssets: boolean): AlbumResponseDto => {
     sharedUsers.push(userDto);
   });
 
+  const assets = entity.assets || [];
+
+  const hasSharedLink = entity.sharedLinks?.length > 0;
+  const hasSharedUser = sharedUsers.length > 0;
+
   return {
     albumName: entity.albumName,
     description: entity.description,
@@ -38,14 +46,17 @@ const _map = (entity: AlbumEntity, withAssets: boolean): AlbumResponseDto => {
     ownerId: entity.ownerId,
     owner: mapUser(entity.owner),
     sharedUsers,
-    shared: sharedUsers.length > 0 || entity.sharedLinks?.length > 0,
-    assets: withAssets ? entity.assets?.map((asset) => mapAsset(asset)) || [] : [],
+    shared: hasSharedUser || hasSharedLink,
+    hasSharedLink,
+    startDate: assets.at(0)?.fileCreatedAt || undefined,
+    endDate: assets.at(-1)?.fileCreatedAt || undefined,
+    assets: (withAssets ? assets : []).map((asset) => mapAsset(asset)),
     assetCount: entity.assets?.length || 0,
   };
 };
 
-export const mapAlbum = (entity: AlbumEntity) => _map(entity, true);
-export const mapAlbumExcludeAssetInfo = (entity: AlbumEntity) => _map(entity, false);
+export const mapAlbumWithAssets = (entity: AlbumEntity) => mapAlbum(entity, true);
+export const mapAlbumWithoutAssets = (entity: AlbumEntity) => mapAlbum(entity, false);
 
 export class AlbumCountResponseDto {
   @ApiProperty({ type: 'integer' })

server/src/domain/album/album.service.spec.ts

@@ -181,6 +181,9 @@ describe(AlbumService.name, () => {
         ownerId: 'admin_id',
         shared: false,
         sharedUsers: [],
+        startDate: undefined,
+        endDate: undefined,
+        hasSharedLink: false,
         updatedAt: expect.anything(),
       });
 
@@ -427,7 +430,7 @@ describe(AlbumService.name, () => {
       albumMock.getById.mockResolvedValue(albumStub.oneAsset);
       accessMock.album.hasOwnerAccess.mockResolvedValue(true);
 
-      await sut.get(authStub.admin, albumStub.oneAsset.id);
+      await sut.get(authStub.admin, albumStub.oneAsset.id, {});
 
       expect(albumMock.getById).toHaveBeenCalledWith(albumStub.oneAsset.id);
       expect(accessMock.album.hasOwnerAccess).toHaveBeenCalledWith(authStub.admin.id, albumStub.oneAsset.id);
@@ -437,7 +440,7 @@ describe(AlbumService.name, () => {
       albumMock.getById.mockResolvedValue(albumStub.oneAsset);
       accessMock.album.hasSharedLinkAccess.mockResolvedValue(true);
 
-      await sut.get(authStub.adminSharedLink, 'album-123');
+      await sut.get(authStub.adminSharedLink, 'album-123', {});
 
       expect(albumMock.getById).toHaveBeenCalledWith('album-123');
       expect(accessMock.album.hasSharedLinkAccess).toHaveBeenCalledWith(
@@ -450,7 +453,7 @@ describe(AlbumService.name, () => {
       albumMock.getById.mockResolvedValue(albumStub.oneAsset);
       accessMock.album.hasSharedAlbumAccess.mockResolvedValue(true);
 
-      await sut.get(authStub.user1, 'album-123');
+      await sut.get(authStub.user1, 'album-123', {});
 
       expect(albumMock.getById).toHaveBeenCalledWith('album-123');
       expect(accessMock.album.hasSharedAlbumAccess).toHaveBeenCalledWith(authStub.user1.id, 'album-123');
@@ -460,7 +463,7 @@ describe(AlbumService.name, () => {
       accessMock.album.hasOwnerAccess.mockResolvedValue(false);
       accessMock.album.hasSharedAlbumAccess.mockResolvedValue(false);
 
-      await expect(sut.get(authStub.admin, 'album-123')).rejects.toBeInstanceOf(BadRequestException);
+      await expect(sut.get(authStub.admin, 'album-123', {})).rejects.toBeInstanceOf(BadRequestException);
 
       expect(accessMock.album.hasOwnerAccess).toHaveBeenCalledWith(authStub.admin.id, 'album-123');
       expect(accessMock.album.hasSharedAlbumAccess).toHaveBeenCalledWith(authStub.admin.id, 'album-123');

server/src/domain/album/album.service.ts

@@ -1,13 +1,19 @@
 import { AlbumEntity, AssetEntity, UserEntity } from '@app/infra/entities';
 import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { AccessCore, IAccessRepository, Permission } from '../access';
-import { BulkIdErrorReason, BulkIdResponseDto, BulkIdsDto, IAssetRepository, mapAsset } from '../asset';
+import { BulkIdErrorReason, BulkIdResponseDto, BulkIdsDto, IAssetRepository } from '../asset';
 import { AuthUserDto } from '../auth';
 import { IJobRepository, JobName } from '../job';
 import { IUserRepository } from '../user';
-import { AlbumCountResponseDto, AlbumResponseDto, mapAlbum } from './album-response.dto';
+import {
+  AlbumCountResponseDto,
+  AlbumResponseDto,
+  mapAlbum,
+  mapAlbumWithAssets,
+  mapAlbumWithoutAssets,
+} from './album-response.dto';
 import { IAlbumRepository } from './album.repository';
-import { AddUsersDto, CreateAlbumDto, GetAlbumsDto, UpdateAlbumDto } from './dto';
+import { AddUsersDto, AlbumInfoDto, CreateAlbumDto, GetAlbumsDto, UpdateAlbumDto } from './dto';
 
 @Injectable()
 export class AlbumService {
@@ -66,21 +72,19 @@ export class AlbumService {
       albums.map(async (album) => {
         const lastModifiedAsset = await this.assetRepository.getLastUpdatedAssetForAlbumId(album.id);
         return {
-          ...album,
-          assets: album?.assets?.map(mapAsset),
-          sharedLinks: undefined, // Don't return shared links
-          shared: album.sharedLinks?.length > 0 || album.sharedUsers?.length > 0,
+          ...mapAlbumWithoutAssets(album),
+          sharedLinks: undefined,
           assetCount: albumsAssetCountObj[album.id],
           lastModifiedAssetTimestamp: lastModifiedAsset?.fileModifiedAt,
-        } as AlbumResponseDto;
+        };
       }),
     );
   }
 
-  async get(authUser: AuthUserDto, id: string) {
+  async get(authUser: AuthUserDto, id: string, dto: AlbumInfoDto) {
     await this.access.requirePermission(authUser, Permission.ALBUM_READ, id);
     await this.albumRepository.updateThumbnails();
-    return mapAlbum(await this.findOrFail(id));
+    return mapAlbum(await this.findOrFail(id), !dto.withoutAssets);
   }
 
   async create(authUser: AuthUserDto, dto: CreateAlbumDto): Promise<AlbumResponseDto> {
@@ -101,7 +105,7 @@ export class AlbumService {
     });
 
     await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ALBUM, data: { ids: [album.id] } });
-    return mapAlbum(album);
+    return mapAlbumWithAssets(album);
   }
 
   async update(authUser: AuthUserDto, id: string, dto: UpdateAlbumDto): Promise<AlbumResponseDto> {
@@ -125,7 +129,7 @@ export class AlbumService {
 
     await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ALBUM, data: { ids: [updatedAlbum.id] } });
 
-    return mapAlbum(updatedAlbum);
+    return mapAlbumWithAssets(updatedAlbum);
   }
 
   async delete(authUser: AuthUserDto, id: string): Promise<void> {
@@ -218,7 +222,7 @@ export class AlbumService {
     return results;
   }
 
-  async addUsers(authUser: AuthUserDto, id: string, dto: AddUsersDto) {
+  async addUsers(authUser: AuthUserDto, id: string, dto: AddUsersDto): Promise<AlbumResponseDto> {
     await this.access.requirePermission(authUser, Permission.ALBUM_SHARE, id);
 
     const album = await this.findOrFail(id);
@@ -243,7 +247,7 @@ export class AlbumService {
         updatedAt: new Date(),
         sharedUsers: album.sharedUsers,
       })
-      .then(mapAlbum);
+      .then(mapAlbumWithAssets);
   }
 
   async removeUser(authUser: AuthUserDto, id: string, userId: string | 'me'): Promise<void> {

server/src/domain/album/dto/album.dto.ts

@@ -0,0 +1,10 @@
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional } from 'class-validator';
+import { toBoolean } from '../../domain.util';
+
+export class AlbumInfoDto {
+  @IsOptional()
+  @IsBoolean()
+  @Transform(toBoolean)
+  withoutAssets?: boolean;
+}

server/src/domain/album/dto/index.ts

@@ -1,4 +1,5 @@
 export * from './album-add-users.dto';
 export * from './album-create.dto';
 export * from './album-update.dto';
+export * from './album.dto';
 export * from './get-albums.dto';

server/src/domain/asset/asset.repository.ts

@@ -58,6 +58,7 @@ export interface TimeBucketOptions {
   isFavorite?: boolean;
   albumId?: string;
   personId?: string;
+  userId?: string;
 }
 
 export interface TimeBucketItem {
@@ -82,6 +83,6 @@ export interface IAssetRepository {
   findLivePhotoMatch(options: LivePhotoSearchOptions): Promise<AssetEntity | null>;
   getMapMarkers(ownerId: string, options?: MapMarkerSearchOptions): Promise<MapMarker[]>;
   getStatistics(ownerId: string, options: AssetStatsOptions): Promise<AssetStats>;
-  getTimeBuckets(userId: string, options: TimeBucketOptions): Promise<TimeBucketItem[]>;
-  getByTimeBucket(userId: string, timeBucket: string, options: TimeBucketOptions): Promise<AssetEntity[]>;
+  getTimeBuckets(options: TimeBucketOptions): Promise<TimeBucketItem[]>;
+  getByTimeBucket(timeBucket: string, options: TimeBucketOptions): Promise<AssetEntity[]>;
 }

server/src/domain/asset/asset.service.ts

@@ -144,18 +144,24 @@ export class AssetService {
     return Promise.all(requests).then((results) => results.filter((result) => result.assets.length > 0));
   }
 
+  private async timeBucketChecks(authUser: AuthUserDto, dto: TimeBucketDto) {
+    if (dto.albumId) {
+      await this.access.requirePermission(authUser, Permission.ALBUM_READ, [dto.albumId]);
+    } else if (dto.userId) {
+      await this.access.requirePermission(authUser, Permission.LIBRARY_READ, [dto.userId]);
+    } else {
+      dto.userId = authUser.id;
+    }
+  }
+
   async getTimeBuckets(authUser: AuthUserDto, dto: TimeBucketDto): Promise<TimeBucketResponseDto[]> {
-    const { userId, ...options } = dto;
-    const targetId = userId || authUser.id;
-    await this.access.requirePermission(authUser, Permission.LIBRARY_READ, [targetId]);
-    return this.assetRepository.getTimeBuckets(targetId, options);
+    await this.timeBucketChecks(authUser, dto);
+    return this.assetRepository.getTimeBuckets(dto);
   }
 
   async getByTimeBucket(authUser: AuthUserDto, dto: TimeBucketAssetDto): Promise<AssetResponseDto[]> {
-    const { userId, timeBucket, ...options } = dto;
-    const targetId = userId || authUser.id;
-    await this.access.requirePermission(authUser, Permission.LIBRARY_READ, [targetId]);
-    const assets = await this.assetRepository.getByTimeBucket(targetId, timeBucket, options);
+    await this.timeBucketChecks(authUser, dto);
+    const assets = await this.assetRepository.getByTimeBucket(dto.timeBucket, dto);
     return assets.map(mapAsset);
   }
 

server/src/domain/search/search.service.ts

@@ -1,7 +1,7 @@
 import { AlbumEntity, AssetEntity, AssetFaceEntity } from '@app/infra/entities';
 import { BadRequestException, Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { mapAlbum } from '../album';
+import { mapAlbumWithAssets } from '../album';
 import { IAlbumRepository } from '../album/album.repository';
 import { AssetResponseDto, mapAsset } from '../asset';
 import { IAssetRepository } from '../asset/asset.repository';
@@ -148,7 +148,7 @@ export class SearchService {
     const lookup = await this.getLookupMap(assets.items.map((asset) => asset.id));
 
     return {
-      albums: { ...albums, items: albums.items.map(mapAlbum) },
+      albums: { ...albums, items: albums.items.map(mapAlbumWithAssets) },
       assets: {
         ...assets,
         items: assets.items

server/src/domain/shared-link/shared-link-response.dto.ts

@@ -1,7 +1,7 @@
 import { SharedLinkEntity, SharedLinkType } from '@app/infra/entities';
 import { ApiProperty } from '@nestjs/swagger';
 import _ from 'lodash';
-import { AlbumResponseDto, mapAlbumExcludeAssetInfo } from '../album';
+import { AlbumResponseDto, mapAlbumWithoutAssets } from '../album';
 import { AssetResponseDto, mapAsset, mapAssetWithoutExif } from '../asset';
 
 export class SharedLinkResponseDto {
@@ -36,7 +36,7 @@ export function mapSharedLink(sharedLink: SharedLinkEntity): SharedLinkResponseD
     createdAt: sharedLink.createdAt,
     expiresAt: sharedLink.expiresAt,
     assets: assets.map(mapAsset),
-    album: sharedLink.album ? mapAlbumExcludeAssetInfo(sharedLink.album) : undefined,
+    album: sharedLink.album ? mapAlbumWithoutAssets(sharedLink.album) : undefined,
     allowUpload: sharedLink.allowUpload,
     allowDownload: sharedLink.allowDownload,
     showExif: sharedLink.showExif,
@@ -58,7 +58,7 @@ export function mapSharedLinkWithNoExif(sharedLink: SharedLinkEntity): SharedLin
     createdAt: sharedLink.createdAt,
     expiresAt: sharedLink.expiresAt,
     assets: assets.map(mapAssetWithoutExif),
-    album: sharedLink.album ? mapAlbumExcludeAssetInfo(sharedLink.album) : undefined,
+    album: sharedLink.album ? mapAlbumWithoutAssets(sharedLink.album) : undefined,
     allowUpload: sharedLink.allowUpload,
     allowDownload: sharedLink.allowDownload,
     showExif: sharedLink.showExif,