UPDATE endpoint for updating an anthology in a library

apps/backend/src/anthology/anthology.controller.ts

@@ -0,0 +1,42 @@
+import {
+  Controller,
+  Get,
+  Delete,
+  Param,
+  ParseIntPipe,
+  UseGuards,
+  UseInterceptors,
+} from '@nestjs/common';
+import { AnthologyService } from './anthology.service';
+import { Anthology } from './anthology.entity';
+import { AuthGuard } from '@nestjs/passport';
+import { CurrentUserInterceptor } from '../interceptors/current-user.interceptor';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Anthologies')
+@ApiBearerAuth()
+@Controller('anthologies')
+@UseGuards(AuthGuard('jwt'))
+@UseInterceptors(CurrentUserInterceptor)
+export class AnthologyController {
+  constructor(private readonly anthologyService: AnthologyService) {}
+
+  @Get('/:id')
+  async getAnthology(
+    @Param('id', ParseIntPipe) id: number,
+  ): Promise<Anthology> {
+    return this.anthologyService.findOne(id);
+  }
+
+  @Get()
+  async getAllAnthologies(): Promise<Anthology[]> {
+    return this.anthologyService.findAll();
+  }
+
+  @Delete('/:id')
+  async removeAnthology(
+    @Param('id', ParseIntPipe) id: number,
+  ): Promise<Anthology> {
+    return this.anthologyService.remove(id);
+  }
+}

apps/backend/src/anthology/anthology.entity.ts

@@ -0,0 +1,49 @@
+import { Entity, Column, IntegerType } from 'typeorm';
+
+import { AnthologyStatus, AnthologyPubLevel } from './types';
+
+@Entity()
+export class Anthology {
+  @Column({ primary: true })
+  id: number;
+
+  @Column()
+  title: string;
+
+  @Column()
+  description: string;
+
+  @Column()
+  published_year: IntegerType;
+
+  @Column({ nullable: true })
+  programs?: string[] | string;
+
+  @Column({ nullable: true })
+  inventory?: IntegerType;
+
+  @Column()
+  status: AnthologyStatus;
+
+  @Column()
+  pub_level: AnthologyPubLevel;
+
+  @Column({ nullable: true })
+  photo_url: string;
+
+  @Column({ nullable: true })
+  genre: string;
+
+  @Column({ nullable: true })
+  theme: string;
+
+  @Column({ nullable: true })
+  isbn: string;
+
+  @Column({ nullable: true })
+  shopify_url: string;
+
+  // TODO once Library is implemented
+  // @Column()
+  // library_id:
+}

apps/backend/src/anthology/anthology.module.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AnthologyController } from './anthology.controller';
+import { AnthologyService } from './anthology.service';
+import { Anthology } from './anthology.entity';
+import { AuthService } from '../auth/auth.service';
+import { JwtStrategy } from '../auth/jwt.strategy';
+import { CurrentUserInterceptor } from '../interceptors/current-user.interceptor';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Anthology])],
+  controllers: [AnthologyController],
+  providers: [
+    AnthologyService,
+    AuthService,
+    JwtStrategy,
+    CurrentUserInterceptor,
+  ],
+})
+export class AnthologyModule {}

apps/backend/src/anthology/anthology.service.ts

@@ -0,0 +1,123 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { Anthology } from './anthology.entity';
+import { AnthologyStatus, AnthologyPubLevel } from './types';
+
+@Injectable()
+export class AnthologyService {
+  constructor(
+    @InjectRepository(Anthology) private repo: Repository<Anthology>,
+  ) {}
+
+  async create(
+    title: string,
+    description: string,
+    published_year: number,
+    status: AnthologyStatus,
+    pub_level: AnthologyPubLevel,
+    programs?: string[] | string,
+    inventory?: number,
+    photo_url?: string,
+    genre?: string,
+    theme?: string,
+    isbn?: string,
+    shopify_url?: string,
+  ) {
+    const anthologyId = (await this.repo.count()) + 1;
+    const anthology = this.repo.create({
+      id: anthologyId,
+      title,
+      description,
+      published_year,
+      status,
+      pub_level,
+      programs,
+      inventory,
+      photo_url,
+      genre,
+      theme,
+      isbn,
+      shopify_url,
+    });
+
+    return this.repo.save(anthology);
+  }
+
+  findOne(id: number) {
+    if (!id) {
+      return null;
+    }
+
+    return this.repo.findOneBy({ id });
+  }
+
+  findAll() {
+    return this.repo.find();
+  }
+
+  findByStatus(status: AnthologyStatus) {
+    return this.repo.find({ where: { status } });
+  }
+
+  findByPubLevel(pub_level: AnthologyPubLevel) {
+    return this.repo.find({ where: { pub_level } });
+  }
+
+  findByYear(published_year: number) {
+    return this.repo.find({ where: { published_year } });
+  }
+
+  findByGenre(genre: string) {
+    return this.repo.find({ where: { genre } });
+  }
+
+  findByTheme(theme: string) {
+    return this.repo.find({ where: { theme } });
+  }
+
+  async update(id: number, attrs: Partial<Anthology>) {
+    const anthology = await this.findOne(id);
+
+    if (!anthology) {
+      throw new NotFoundException('Anthology not found');
+    }
+
+    Object.assign(anthology, attrs);
+
+    return this.repo.save(anthology);
+  }
+
+  async remove(id: number) {
+    const anthology = await this.findOne(id);
+
+    if (!anthology) {
+      throw new NotFoundException('Anthology not found');
+    }
+
+    return this.repo.remove(anthology);
+  }
+
+  async updateInventory(id: number, inventory: number) {
+    const anthology = await this.findOne(id);
+
+    if (!anthology) {
+      throw new NotFoundException('Anthology not found');
+    }
+
+    anthology.inventory = inventory;
+    return this.repo.save(anthology);
+  }
+
+  async updateStatus(id: number, status: AnthologyStatus) {
+    const anthology = await this.findOne(id);
+
+    if (!anthology) {
+      throw new NotFoundException('Anthology not found');
+    }
+
+    anthology.status = status;
+    return this.repo.save(anthology);
+  }
+}

apps/backend/src/anthology/dtos/create-anthology.dto.ts

@@ -0,0 +1,78 @@
+import {
+  IsString,
+  IsNumber,
+  IsOptional,
+  IsEnum,
+  IsArray,
+} from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { AnthologyStatus, AnthologyPubLevel } from '../types';
+
+export class CreateAnthologyDto {
+  @ApiProperty({ description: 'Title of the anthology' })
+  @IsString()
+  title: string;
+
+  @ApiProperty({ description: 'Description of the anthology' })
+  @IsString()
+  description: string;
+
+  @ApiProperty({ description: 'Year the anthology was published' })
+  @IsNumber()
+  published_year: number;
+
+  @ApiProperty({
+    description: 'Status of the anthology',
+    enum: AnthologyStatus,
+    example: AnthologyStatus.DRAFTING,
+  })
+  @IsEnum(AnthologyStatus)
+  status: AnthologyStatus;
+
+  @ApiProperty({
+    description: 'Publication level of the anthology',
+    enum: AnthologyPubLevel,
+    example: AnthologyPubLevel.ZINE,
+  })
+  @IsEnum(AnthologyPubLevel)
+  pub_level: AnthologyPubLevel;
+
+  @ApiPropertyOptional({
+    description: 'Programs associated with the anthology',
+    type: [String],
+  })
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  programs?: string[];
+
+  @ApiPropertyOptional({ description: 'Inventory count' })
+  @IsOptional()
+  @IsNumber()
+  inventory?: number;
+
+  @ApiPropertyOptional({ description: 'URL to anthology photo' })
+  @IsOptional()
+  @IsString()
+  photo_url?: string;
+
+  @ApiPropertyOptional({ description: 'Genre of the anthology' })
+  @IsOptional()
+  @IsString()
+  genre?: string;
+
+  @ApiPropertyOptional({ description: 'Theme of the anthology' })
+  @IsOptional()
+  @IsString()
+  theme?: string;
+
+  @ApiPropertyOptional({ description: 'ISBN of the anthology' })
+  @IsOptional()
+  @IsString()
+  isbn?: string;
+
+  @ApiPropertyOptional({ description: 'Shopify URL for purchasing' })
+  @IsOptional()
+  @IsString()
+  shopify_url?: string;
+}

apps/backend/src/anthology/dtos/update-anthology.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateAnthologyDto } from './create-anthology.dto';
+
+export class UpdateAnthologyDto extends PartialType(CreateAnthologyDto) {}

apps/backend/src/anthology/types.ts

@@ -0,0 +1,13 @@
+export enum AnthologyStatus {
+  ARCHIVED = 'Archived',
+  NOT_STARTED = 'NotStarted',
+  DRAFTING = 'Drafting',
+  CAN_BE_SHARED = 'CanBeShared',
+}
+
+export enum AnthologyPubLevel {
+  ZINE = 'Zine',
+  CHAPBOOK = 'Chapbook',
+  PERFECT_BOUND = 'PerfectBound',
+  SIGNATURE = 'Signature',
+}

apps/backend/src/app.module.ts

@@ -3,11 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
-import { TaskModule } from './task/task.module';
 import AppDataSource from './data-source';
 
 @Module({
-  imports: [TypeOrmModule.forRoot(AppDataSource.options), TaskModule],
+  imports: [TypeOrmModule.forRoot(AppDataSource.options)],
   controllers: [AppController],
   providers: [AppService],
 })

apps/backend/src/data-source.ts

@@ -1,6 +1,5 @@
 import { DataSource } from 'typeorm';
 import { PluralNamingStrategy } from './strategies/plural-naming.strategy';
-import { Task } from './task/types/task.entity';
 import * as dotenv from 'dotenv';
 
 dotenv.config();
@@ -12,7 +11,7 @@ const AppDataSource = new DataSource({
   username: process.env.NX_DB_USERNAME,
   password: process.env.NX_DB_PASSWORD,
   database: process.env.NX_DB_DATABASE,
-  entities: [Task],
+  entities: [],
   migrations: ['apps/backend/src/migrations/*.js'],
   // Setting synchronize: true shouldn't be used in production - otherwise you can lose production data
   synchronize: false,