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
2026-01-23 09:36:19 +00:00 · 2023-08-11 12:00:51 -04:00
parent 36dc7bd924
commit 5cd13227ad
47 changed files with 1014 additions and 757 deletions
--- a/server/src/domain/album/album-response.dto.ts
+++ b/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' })
--- a/server/src/domain/album/album.service.spec.ts
+++ b/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');
--- a/server/src/domain/album/album.service.ts
+++ b/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> {
--- a/server/src/domain/album/dto/album.dto.ts
+++ b/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;
+}
--- a/server/src/domain/album/dto/index.ts
+++ b/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';