feat(web): show partners assets on the main timeline (#4933)

server/src/domain/partner/partner.dto.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty } from 'class-validator';
+import { UserResponseDto } from '../user';
+
+export class UpdatePartnerDto {
+  @IsNotEmpty()
+  inTimeline!: boolean;
+}
+
+export class PartnerResponseDto extends UserResponseDto {
+  inTimeline?: boolean;
+}

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

@@ -1,11 +1,11 @@
 import { BadRequestException } from '@nestjs/common';
 import { authStub, newPartnerRepositoryMock, partnerStub } from '@test';
-import { UserResponseDto } from '../index';
-import { IPartnerRepository, PartnerDirection } from '../repositories';
+import { IAccessRepository, IPartnerRepository, PartnerDirection } from '../repositories';
+import { PartnerResponseDto } from './partner.dto';
 import { PartnerService } from './partner.service';
 
 const responseDto = {
-  admin: <UserResponseDto>{
+  admin: <PartnerResponseDto>{
     email: 'admin@test.com',
     firstName: 'admin_first_name',
     id: 'admin_id',
@@ -20,8 +20,9 @@ const responseDto = {
     updatedAt: new Date('2021-01-01'),
     externalPath: null,
     memoriesEnabled: true,
+    inTimeline: true,
   },
-  user1: <UserResponseDto>{
+  user1: <PartnerResponseDto>{
     email: 'immich@test.com',
     firstName: 'immich_first_name',
     id: 'user-id',
@@ -36,16 +37,18 @@ const responseDto = {
     updatedAt: new Date('2021-01-01'),
     externalPath: null,
     memoriesEnabled: true,
+    inTimeline: true,
   },
 };
 
 describe(PartnerService.name, () => {
   let sut: PartnerService;
   let partnerMock: jest.Mocked<IPartnerRepository>;
+  let accessMock: jest.Mocked<IAccessRepository>;
 
   beforeEach(async () => {
     partnerMock = newPartnerRepositoryMock();
-    sut = new PartnerService(partnerMock);
+    sut = new PartnerService(partnerMock, accessMock);
   });
 
   it('should work', () => {

server/src/domain/partner/partner.service.ts

@@ -1,14 +1,22 @@
 import { PartnerEntity } from '@app/infra/entities';
 import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { AccessCore, Permission } from '../access';
 import { AuthUserDto } from '../auth';
-import { IPartnerRepository, PartnerDirection, PartnerIds } from '../repositories';
-import { UserResponseDto, mapUser } from '../user';
+import { IAccessRepository, IPartnerRepository, PartnerDirection, PartnerIds } from '../repositories';
+import { mapUser } from '../user';
+import { PartnerResponseDto, UpdatePartnerDto } from './partner.dto';
 
 @Injectable()
 export class PartnerService {
-  constructor(@Inject(IPartnerRepository) private repository: IPartnerRepository) {}
+  private access: AccessCore;
+  constructor(
+    @Inject(IPartnerRepository) private repository: IPartnerRepository,
+    @Inject(IAccessRepository) accessRepository: IAccessRepository,
+  ) {
+    this.access = AccessCore.create(accessRepository);
+  }
 
-  async create(authUser: AuthUserDto, sharedWithId: string): Promise<UserResponseDto> {
+  async create(authUser: AuthUserDto, sharedWithId: string): Promise<PartnerResponseDto> {
     const partnerId: PartnerIds = { sharedById: authUser.id, sharedWithId };
     const exists = await this.repository.get(partnerId);
     if (exists) {
@@ -29,7 +37,7 @@ export class PartnerService {
     await this.repository.remove(partner);
   }
 
-  async getAll(authUser: AuthUserDto, direction: PartnerDirection): Promise<UserResponseDto[]> {
+  async getAll(authUser: AuthUserDto, direction: PartnerDirection): Promise<PartnerResponseDto[]> {
     const partners = await this.repository.getAll(authUser.id);
     const key = direction === PartnerDirection.SharedBy ? 'sharedById' : 'sharedWithId';
     return partners
@@ -38,8 +46,22 @@ export class PartnerService {
       .map((partner) => this.map(partner, direction));
   }
 
-  private map(partner: PartnerEntity, direction: PartnerDirection): UserResponseDto {
+  async update(authUser: AuthUserDto, sharedById: string, dto: UpdatePartnerDto): Promise<PartnerResponseDto> {
+    await this.access.requirePermission(authUser, Permission.PARTNER_UPDATE, sharedById);
+    const partnerId: PartnerIds = { sharedById, sharedWithId: authUser.id };
+
+    const entity = await this.repository.update({ ...partnerId, inTimeline: dto.inTimeline });
+    return this.map(entity, PartnerDirection.SharedWith);
+  }
+
+  private map(partner: PartnerEntity, direction: PartnerDirection): PartnerResponseDto {
     // this is opposite to return the non-me user of the "partner"
-    return mapUser(direction === PartnerDirection.SharedBy ? partner.sharedWith : partner.sharedBy);
+    const user = mapUser(
+      direction === PartnerDirection.SharedBy ? partner.sharedWith : partner.sharedBy,
+    ) as PartnerResponseDto;
+
+    user.inTimeline = partner.inTimeline;
+
+    return user;
   }
 }