Controle de produção

server/.gitignore

@@ -11,4 +11,7 @@ node_modules/
 dist/
 
 # logs
-**/*.log
+**/*.log
+
+# misc
+.vscode/

server/package.json

@@ -20,14 +20,14 @@
     "eslint-plugin-import": "^2.25.2",
     "eslint-plugin-n": "^15.0.0",
     "eslint-plugin-promise": "^6.0.0",
-    "prisma": "^5.2.0",
+    "prisma": "^5.18.0",
     "tsx": "^4.7.0",
     "typescript": "*",
     "vitest": "^0.28.5",
     "zod": "^3.20.6"
   },
   "dependencies": {
-    "@prisma/client": "^5.2.0",
+    "@prisma/client": "^5.10.2",
     "@types/cors": "^2.8.13",
     "bcrypt": "^5.1.0",
     "bcryptjs": "^2.4.3",

server/prisma/migrations/20230612165801_create_animal_gender_table/migration.sql → server/prisma/migrations/20240224155437_create_gender_table/migration.sql

@@ -5,15 +5,18 @@
 
 */
 -- AlterTable
-ALTER TABLE "animals" ADD COLUMN     "gender" DECIMAL(65,30) NOT NULL;
+ALTER TABLE "animals" ADD COLUMN     "gender" INTEGER NOT NULL;
 
 -- CreateTable
 CREATE TABLE "genders" (
-    "id" DECIMAL(65,30) NOT NULL,
-    "type" DECIMAL(65,30) NOT NULL,
+    "id" SERIAL NOT NULL,
+    "type" TEXT NOT NULL,
 
     CONSTRAINT "genders_pkey" PRIMARY KEY ("id")
 );
 
+-- CreateIndex
+CREATE UNIQUE INDEX "genders_type_key" ON "genders"("type");
+
 -- AddForeignKey
 ALTER TABLE "animals" ADD CONSTRAINT "animals_gender_fkey" FOREIGN KEY ("gender") REFERENCES "genders"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

server/prisma/migrations/20240224155522_create_production_control/migration.sql

@@ -0,0 +1,13 @@
+-- CreateTable
+CREATE TABLE "animal_productions" (
+    "id" TEXT NOT NULL,
+    "animal_id" TEXT NOT NULL,
+    "date" TIMESTAMP(3) NOT NULL,
+    "goal" TEXT NOT NULL,
+    "price" DECIMAL(65,30) NOT NULL,
+
+    CONSTRAINT "animal_productions_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "animal_productions" ADD CONSTRAINT "animal_productions_animal_id_fkey" FOREIGN KEY ("animal_id") REFERENCES "animals"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

server/prisma/schema.prisma

@@ -35,7 +35,7 @@ model Animal {
   owner    User   @relation(fields: [ownerId], references: [id])
   genderId Gender @relation(fields: [gender], references: [id])
 
-  AnimalProduction AnimalProduction[]
+  production Production[]
 
   @@map("animals")
 }
@@ -49,7 +49,7 @@ model Gender {
   @@map("genders")
 }
 
-model AnimalProduction {
+model Production {
   id       String   @id @default(uuid())
   animalId String   @map("animal_id")
   date     DateTime

server/src/controllers/Production/createProductionController.ts

@@ -0,0 +1,30 @@
+import { Request, Response } from "express";
+import { z } from "zod";
+import { CreateProduction } from "../../services/Production/createProduction";
+import { ProductionViewModel } from "../../views/ProductionViewModel";
+
+export class CreateProductionController {
+  constructor (
+    private createProduction: CreateProduction,
+  ) {}
+
+  async handle(request: Request, response: Response) {
+    const CreateAnimalProps = z.object({
+      animalId: z.string(),
+      date: z.string(),
+      goal: z.string(),
+      price: z.number(),
+    });
+
+    const { animalId, date, goal, price } = CreateAnimalProps.parse(request.body);
+
+    const production = await this.createProduction.execute({
+      animalId,
+      date: new Date(date),
+      goal,
+      price,
+    });
+
+    return response.status(201).json(ProductionViewModel.toHTTP(production));
+  }
+}

server/src/controllers/Production/findManyProductionsController.ts

@@ -0,0 +1,17 @@
+import { Request, Response } from "express";
+import { FindManyProductions } from "../../services/Production/findManyProductions";
+import { ProductionViewModel } from "../../views/ProductionViewModel";
+
+export class FindManyProductionsController {
+  constructor(
+    private findManyProductions: FindManyProductions,
+  ) {}
+
+  async handle(request: Request, response: Response) {
+    const { ownerId } = request.params;
+
+    const productions = await this.findManyProductions.execute(ownerId);
+
+    return response.json(productions.map((production) => ProductionViewModel.toHTTP(production)));
+  }
+}

server/src/controllers/Production/index.ts

@@ -0,0 +1,8 @@
+import { createProduction, findManyProductions } from "../../services/Production";
+import { CreateProductionController } from "./createProductionController";
+import { FindManyProductionsController } from "./findManyProductionsController";
+
+const createProductionController = new CreateProductionController(createProduction);
+const findManyProductionsController = new FindManyProductionsController(findManyProductions);
+
+export { createProductionController, findManyProductionsController };

server/src/database/index.ts

@@ -1,9 +1,15 @@
 import { PrismaClient } from "@prisma/client";
 import { PrismaAnimalsRepository } from "./prisma/PrismaAnimalsRepository";
 import { PrismaUsersRepository } from "./prisma/PrismaUsersRepository";
+import { PrismaProductionRepository } from "./prisma/PrismaProductionRepository";
 
 const prisma = new PrismaClient();
 const prismaAnimalsRepository = new PrismaAnimalsRepository(prisma);
 const prismaUsersRepository = new PrismaUsersRepository(prisma);
+const prismaProduction = new PrismaProductionRepository(prisma);
 
-export { prismaAnimalsRepository, prismaUsersRepository };
+export { 
+  prismaAnimalsRepository, 
+  prismaUsersRepository, 
+  prismaProduction
+};

server/src/database/mappers/PrismaProductionMappers.ts

@@ -0,0 +1,23 @@
+import { ProductionProps } from "../../dtos/AnimalsDTO";
+
+export class PrismaProduction {
+  static toPrisma(data: ProductionProps) {
+    return {
+      id: data.id,
+      animalId: data.animalId,
+      date: data.date,
+      goal: data.goal,
+      price: data.price,
+    };
+  }
+
+  static toDomain(raw: any) {
+    return {
+      id: raw.id,
+      animalId: raw.animalId,
+      date: new Date(raw.date),
+      goal: raw.goal,
+      price: Number(raw.price),
+    };
+  }
+}

server/src/database/prisma/PrismaProductionRepository.ts

@@ -0,0 +1,67 @@
+import { PrismaClient } from "@prisma/client";
+import { ProductionRepository } from "../../repositories/ProductionRepository";
+import { ProductionProps } from "../../dtos/AnimalsDTO";
+import { PrismaProduction } from "../mappers/PrismaProductionMappers";
+
+export class PrismaProductionRepository implements ProductionRepository {
+  constructor (
+    private prisma: PrismaClient,
+  ) {}
+
+  async create(props: ProductionProps): Promise<void> {
+    const raw = PrismaProduction.toPrisma(props);
+
+    await this.prisma.production.create({
+      data: raw
+    });
+  }
+
+  async findByAnimalId(id: string): Promise<ProductionProps | null> {
+    const animalExists = await this.prisma.production.findFirst({
+      where: {
+        animalId: id,
+      }
+    });
+
+    if(!animalExists) {
+      return null;
+    }
+
+    return PrismaProduction.toDomain(animalExists);
+  }
+
+  async findMany(ownerId: string): Promise<ProductionProps[]> {
+    const animals = await this.prisma.production.findMany({
+      where: {
+        animal: {
+          ownerId,
+        }
+      }
+    });
+
+    return animals.map(PrismaProduction.toDomain);
+  }
+
+  async save(props: ProductionProps): Promise<void> {
+    const raw = PrismaProduction.toPrisma(props);
+
+    await this.prisma.production.update({
+      where: {
+        id: raw.id,
+      },
+      data: raw,
+    });
+
+    return;
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.prisma.production.delete({
+      where: {
+        id,
+      }
+    });
+
+    return;
+  }
+}

server/src/entities/Production.spec.ts

@@ -0,0 +1,38 @@
+import { randomUUID } from 'crypto';
+import { describe, expect, it } from 'vitest';
+import Production from './Production';
+
+describe("Production", () => {
+  it("Should be able to create a new production", () => {
+    const raw = {
+      animalId: randomUUID(),
+      date: new Date(),
+      goal: "Engorda",
+      price: 1250.00,
+    };
+
+    const animal = new Production(raw);
+
+    expect(animal).toBeTruthy();
+    expect(animal).toHaveProperty("id");
+    expect(animal).toContain({
+      id: animal.id,
+      ...raw,
+    });
+  });
+
+  it("Should be able to create a instance to an existing production", () => {
+    const id = randomUUID();
+
+    const animal = new Production({
+      animalId: randomUUID(),
+      date: new Date(),
+      goal: "Engorda",
+      price: 1250.00,
+    }, id);
+
+    expect(animal).toBeTruthy();
+    expect(animal).toHaveProperty("id");
+    expect(animal.id).toBe(id);
+  });
+});

server/src/entities/Production.ts

@@ -0,0 +1,38 @@
+import { randomUUID } from "crypto";
+
+interface ProductionProps {
+  animalId: string;
+  date: Date;
+  goal: string;
+  price: number;
+}
+
+export default class Production {
+  private _id: string;
+  private props: ProductionProps; 
+
+  constructor(props: ProductionProps, id?: string) {
+    this.props = props;
+    this._id = id ?? randomUUID();
+  }
+
+  public get id(): string {
+    return this._id;
+  }
+
+  public get animalId() {
+    return this.props.animalId;
+  }
+
+  public get date() {
+    return this.props.date;
+  }
+
+  public get goal() {
+    return this.props.goal;
+  }
+
+  public get price() {
+    return this.props.price;
+  }
+}

server/src/repositories/ProductionRepository.ts

@@ -0,0 +1,9 @@
+import Production from "../entities/Production";
+
+export abstract class ProductionRepository {
+  abstract create(props: Production): Promise<void>;
+  abstract findByAnimalId(id: string): Promise<Production | null>;
+  abstract findMany(ownerId: string): Promise<Production[]>;
+  abstract save(props: Production): Promise<void>;
+  abstract delete(id: string): Promise<void>;
+}