87 seed data in backend

.gitignore

@@ -41,4 +41,7 @@ Thumbs.db
 # Environment file
 *.env
 *.env.*
-!example.env
+!example.env
+
+# Cache
+.nx/cache

apps/backend/project.json

@@ -31,6 +31,12 @@
         "production": {}
       }
     },
+    "seed": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "ts-node -r tsconfig-paths/register --project apps/backend/tsconfig.seed.json apps/backend/src/seeds/index.ts"
+      }
+    },
     "serve": {
       "executor": "@nx/js:node",
       "defaultConfiguration": "development",

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

@@ -0,0 +1,50 @@
+import {
+  Controller,
+  Get,
+  Delete,
+  Param,
+  ParseIntPipe,
+  UseGuards,
+  UseInterceptors,
+  NotFoundException,
+} 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> {
+    const anthology = await this.anthologyService.findOne(id);
+
+    if (!anthology) {
+      throw new NotFoundException(`Anthology with ID ${id} not found`);
+    }
+
+    return anthology;
+  }
+
+  @Get()
+  async getAllAnthologies(): Promise<Anthology[]> {
+    return this.anthologyService.findAll();
+  }
+
+  @Delete('/:anthologyId')
+  async removeAnthology(
+    @Param('anthologyId', ParseIntPipe) anthologyId: number,
+  ): Promise<{ message: string }> {
+    await this.anthologyService.remove(anthologyId);
+    return { message: 'Anthology deleted successfully' };
+  }
+}

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

@@ -0,0 +1,100 @@
+import {
+  Entity,
+  Column,
+  IntegerType,
+  PrimaryGeneratedColumn,
+  OneToMany,
+  ManyToOne,
+  OneToOne,
+  Relation,
+} from 'typeorm';
+
+import { AnthologyStatus, AnthologyPubLevel, AgeCategory } from './types';
+
+import { Story } from '../story/story.entity';
+import { InventoryHolding } from '../inventory-holding/inventory-holding.entity';
+import { ProductionInfo } from '../production-info/production-info.entity';
+import { Omchai } from 'src/omchai/omchai.entity';
+
+@Entity()
+export class Anthology {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  title: string;
+
+  @Column({ default: '' })
+  byline: string;
+
+  @Column({ nullable: true })
+  subtitle: 'A College Essay Anthology';
+
+  @Column()
+  description: string;
+
+  @Column({ type: 'simple-array', default: [] })
+  genres: string[];
+
+  @Column({ type: 'simple-array', default: [] })
+  themes: string[];
+
+  @Column({ type: 'simple-array', default: [] })
+  triggers: string[];
+
+  @Column({ name: 'published_date', type: 'date' })
+  publishedDate: Date;
+
+  @Column({ type: 'simple-array', nullable: true })
+  programs?: string[];
+
+  @Column({ type: 'simple-array', nullable: true })
+  sponsors?: string[];
+
+  @Column({ type: 'enum', enum: AnthologyStatus })
+  status: AnthologyStatus;
+
+  @Column({
+    type: 'enum',
+    enum: AgeCategory,
+    name: 'age_category',
+    nullable: true,
+  })
+  ageCategory: AgeCategory;
+
+  @Column({
+    name: 'pub_level',
+    type: 'enum',
+    enum: AnthologyPubLevel,
+  })
+  pubLevel: AnthologyPubLevel;
+
+  @Column({
+    name: 'photo_url',
+    nullable: true,
+    default: '',
+  })
+  photoUrl: string;
+
+  @Column({ nullable: true })
+  isbn: string;
+
+  @Column({
+    name: 'shopify_url',
+    nullable: true,
+    default: '',
+  })
+  shopifyUrl: string;
+
+  @OneToMany(() => Story, (story) => story.anthology)
+  stories: Relation<Story[]>;
+
+  @OneToMany(() => InventoryHolding, (holding) => holding.anthology)
+  inventoryHoldings: Relation<InventoryHolding[]>;
+
+  @OneToOne(
+    () => ProductionInfo,
+    (productionInfo) => productionInfo.anthology_id,
+  )
+  productionInfo: ProductionInfo;
+}

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

@@ -0,0 +1,18 @@
+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';
+import { AuthModule } from '../auth/auth.module';
+import { UsersModule } from '../users/users.module';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Anthology]), AuthModule, UsersModule],
+  controllers: [AnthologyController],
+  providers: [AnthologyService, CurrentUserInterceptor],
+  exports: [AnthologyService],
+})
+export class AnthologyModule {}

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

@@ -0,0 +1,98 @@
+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,
+    publishedDate: string,
+    status: AnthologyStatus,
+    pubLevel: AnthologyPubLevel,
+    programs?: string[],
+    photoUrl?: string,
+    isbn?: string,
+    shopifyUrl?: string,
+  ) {
+    const anthologyId = (await this.repo.count()) + 1;
+    const anthology = this.repo.create({
+      id: anthologyId,
+      title,
+      description,
+      publishedDate,
+      status,
+      pubLevel,
+      programs,
+      photoUrl,
+      isbn,
+      shopifyUrl,
+    });
+
+    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(pubLevel: AnthologyPubLevel) {
+    return this.repo.find({ where: { pubLevel } });
+  }
+
+  findByYear(publishedDate: Date) {
+    return this.repo.find({ where: { publishedDate } });
+  }
+
+  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 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,79 @@
+import {
+  IsString,
+  IsNumber,
+  IsOptional,
+  IsEnum,
+  IsArray,
+} from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { AnthologyStatus, AnthologyPubLevel } from '../types';
+
+//TODO: outdated DTO needs to match the schema
+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,17 @@
+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',
+}
+
+export enum AgeCategory {
+  YA = 'Young Adult Books (Ages 13-18)',
+}