Camada: Domain

Componente: Entity
export class newOrder {
constructor(
public readonly userCostumer: number,
public readonly userSeller: number,
public readonly fkCurrency: number,
public readonly fkOrderStatus: number,
public readonly fkShippingAddress: number,
public readonly totalAmount: number,
public readonly fkCoupon?: number,
public readonly createdDt?: Date,

) {}
}

export class Order extends newOrder {

constructor(
public readonly id: number,
userCostumer?: number,
userSeller?: number,
fkCurrency?: number,
fkOrderStatus?: number,
fkShippingAddress?: number,
fkCoupon?: number,
totalAmount?: number,
createdDt?: Date,
) {
super(userCostumer!, userSeller!,
fkCurrency!, fkOrderStatus!, fkShippingAddress!,
fkCoupon,
totalAmount!, createdDt
);
}
}
Componente: Repository

import { newOrder, Order } from

"src/Domain/Entities/Market/order.entity";

export interface OrderRepository {

create(order: newOrder): Promise<newOrder>;
update(order: Order): Promise<Order>;
delete(id: number): Promise<void>;

findAll(): Promise<Order[]>;
findById(id: number): Promise<Order | null>;

findByCustomer(userCostumer: number): Promise<Order[]>;

findBySeller(userSeller: number): Promise<Order[]>;

findByStatus(status: number): Promise<Order[]>;

}
Componente: Service

import { Inject, Injectable } from "@nestjs/common";

import { newOrder, Order } from
"src/Domain/Entities/Market/order.entity";
import { OrderRepository } from
"src/Domain/Repositories/Market/order.repository";

@Injectable()
export class OrderService {
constructor(
@Inject('OrderRepository')
private readonly orderRepository: OrderRepository,
) {}

async createOrder(data: newOrder): Promise<newOrder> {

const order = new newOrder(
data.userCostumer, data.userSeller,
data.fkCurrency, data.fkOrderStatus,
data.fkShippingAddress,
data.totalAmount,
data.fkCoupon, data.createdDt
)

return this.orderRepository.create(order);
}

async updateOrder(data: Order): Promise<Order> {

const order = new Order(

data.id,
data.userCostumer, data.userSeller,
data.fkCurrency, data.fkOrderStatus,
data.fkShippingAddress, data.fkCoupon,
data.totalAmount,
data.createdDt

)
return this.orderRepository.update(order);
}

async deleteOrder(id: number): Promise<void> {

await this.orderRepository.delete(+id);
}

async findAllOrders(): Promise<Order[]> {

return this.orderRepository.findAll();
 }
async findOrderById(id: number): Promise<Order | null> {
return this.orderRepository.findById(+id)
}

async findOrdersByCustomer(userCostumer: number):

Promise<Order[]> {
return this.orderRepository.findByCustomer(+userCostumer);
}

async findOrdersBySeller(userSeller: number): Promise<Order[]>

{
return this.orderRepository.findBySeller(+userSeller);
}
}
Camada: Application

Componente: Use Case (Cadastro)

import { Injectable } from "@nestjs/common";

import { OrderService } from
"src/Domain/Services/Market/order.service";
import { newOrder } from "src/Domain/Entities/Market/order.entity";
import { OrderCreateDto } from
"src/Interface/dto/Market/order.create-dto";

@Injectable()
export class CreateOrderUseCase {
constructor(private readonly orderService: OrderService) {}

async execute(dataDto: OrderCreateDto): Promise<newOrder> {

const order: newOrder = {
userCostumer: dataDto.userCostumer,
userSeller: dataDto.userSeller,
fkCurrency: dataDto.fkCurrency,
fkOrderStatus: dataDto.fkOrderStatus,
fkShippingAddress: dataDto.fkShippingAddress,
totalAmount: dataDto.totalAmount,
fkCoupon: dataDto.fkCoupon,
};

return await this.orderService.createOrder(order);

}
}
Componente: Use Case (Exclusão)

import { Injectable } from "@nestjs/common";

import { OrderService } from
"src/Domain/Services/Market/order.service";

@Injectable()
export class DeleteOrderUseCase {
constructor(private readonly orderService: OrderService) {}

async execute(id: number): Promise<void> {

return await this.orderService.deleteOrder(id);
}
}
Componente: Use Case (Alteração)

import { Injectable } from "@nestjs/common";

import { OrderService } from
"src/Domain/Services/Market/order.service";
import { Order } from "src/Domain/Entities/Market/order.entity";
import { OrderUpdateDto } from
"src/Interface/dto/Market/order.update-dto";

@Injectable()
export class UpdateOrderUseCase {
constructor(private readonly orderService: OrderService) {}

async execute(dataDto: OrderUpdateDto): Promise<Order> {

const order: Order = {
id: dataDto.id,
userCostumer: dataDto.userCostumer,
userSeller: dataDto.userSeller,
fkCurrency: dataDto.fkCurrency,
fkOrderStatus: dataDto.fkOrderStatus,
fkShippingAddress: dataDto.fkShippingAddress,
fkCoupon: dataDto.fkCoupon,
totalAmount: dataDto.totalAmount,
};

return await this.orderService.updateOrder(order);

}
}
Componente: Use Case (Busca por id)

import { Injectable } from "@nestjs/common";

import { OrderService } from
"src/Domain/Services/Market/order.service";
import { Order } from "src/Domain/Entities/Market/order.entity";

@Injectable()
export class FindOrderByIdUseCase {
constructor(private readonly orderService: OrderService) {}

async execute(id: number): Promise<Order | null> {

return await this.orderService.findOrderById(+id);
}
}
Componente: Use Case (Busca por vendedor)

import { Injectable } from "@nestjs/common";

import { OrderService } from
"src/Domain/Services/Market/order.service";
import { Order } from "src/Domain/Entities/Market/order.entity";

@Injectable()
export class FindOrdersBySellerUseCase {
constructor(private readonly orderService: OrderService) {}

async execute(userSeller: number): Promise<Order[]> {

return await
this.orderService.findOrdersBySeller(+userSeller);
}
}
Camada: Interface

Componente: Controller

import { Body, Controller, Delete, Get, Param, Patch, Post } from

"@nestjs/common";

import { CreateOrderUseCase } from

"src/Application/use-cases/Marketplace/order/create-order.use-
case";
import { DeleteOrderUseCase } from
"src/Application/use-cases/Marketplace/order/delete-order.use-
case";
import { FindAllOrdersUseCase } from
"src/Application/use-cases/Marketplace/order/find-all-orders.use-
case";
import { FindOrderByIdUseCase } from
"src/Application/use-cases/Marketplace/order/find-order-by-id.use-
case copy";
import { FindOrdersByCustomerUseCase } from "src/Application/use-
cases/Marketplace/order/find-orders-by-customer.use-case";
import { FindOrdersBySellerUseCase } from "src/Application/use-
cases/Marketplace/order/find-orders-by-seller.use-case";
import { UpdateOrderUseCase } from
"src/Application/use-cases/Marketplace/order/update-order.use-
case";

import { OrderCreateDto } from

"src/Interface/dto/Market/order.create-dto";
import { OrderUpdateDto } from
"src/Interface/dto/Market/order.update-dto";

@Controller('order')
export class OrderController {
constructor(
private readonly createOrderUseCase: CreateOrderUseCase,
private readonly updateOrderUseCase: UpdateOrderUseCase,
private readonly deleteOrderUseCase: DeleteOrderUseCase,
private readonly findAllOrdersUseCase:
FindAllOrdersUseCase,
private readonly findOrderByIdUseCase:
FindOrderByIdUseCase,
private readonly findOrderByCustomerUseCase:
FindOrdersByCustomerUseCase,
 private readonly findOrdersBySellerUseCase:
FindOrdersBySellerUseCase,
) {}

@Post('new')
async create(@Body() data: OrderCreateDto) {
return this.createOrderUseCase.execute(data);
}

@Patch('update:id')
async update(@Param('id') id: number, @Body() data:
OrderUpdateDto) {
data.id = id;
return this.updateOrderUseCase.execute(data);
}

@Delete(':id')
async remove(@Param('id') id: number) {
return this.deleteOrderUseCase.execute(id);
}

@Get('orders')
async findAll() {
return this.findAllOrdersUseCase.execute();
}

@Get('order/:id')
async findById(@Param('id') id: number) {
return this.findOrderByIdUseCase.execute(+id)
}

@Get('customer/:customer')
async findByCustomer(@Param('customer') customer: number) {
return this.findOrderByIdUseCase.execute(+customer)
}

@Get('seller/:seller')
async findBySeller(@Param('seller') seller: number) {
return this.findOrderByIdUseCase.execute(+seller)
}

}
Componente: Dto (create)
import { IsNotEmpty, IsInt, IsDate, IsNumber, IsOptional, Matches }
from "class-validator";

export class OrderCreateDto {

@IsNotEmpty({ message: "O campo 'userCostumer' não pode estar

vazio." })
@IsInt( { message: "O campo 'userCostumer' deve ser um número."
})
userCostumer: number;

@IsNotEmpty({ message: "O campo 'userSeller' não pode estar

vazio." })
@IsInt( { message: "O campo 'userSeller' deve ser um
número." })
userSeller: number;

@IsNotEmpty({ message: "O campo 'fkOrderStatus' não pode estar

vazio." })
@IsInt( { message: "O campo 'fkOrderStatus' deve ser um
número." })
fkOrderStatus: number;

@IsNotEmpty({ message: "O campo não pode estar vazio." })

@IsInt( { message: "O campo deve ser um número." })
fkPaymentMethod: number;

@IsNotEmpty({ message: "O campo não pode estar vazio." })

@IsInt( { message: "O campo deve ser um número." })
fkCurrency: number;

@IsNotEmpty({ message: "O campo não pode estar vazio." })

@IsInt( { message: "O campo deve ser um número." })
fkShippingAddress: number;

@IsOptional()
@IsInt( { message: "O campo deve ser um número." })
fkCoupon?: number;

@IsNotEmpty({ message: "O campo não pode estar vazio." })

@IsNumber({ }, { message: "O campo deve ser um número decimal."
})
@Matches(/^\d+(\.\d{1,2})?$/, { message: "O campo deve ter no
máximo 2 casas decimais." })
totalAmount: number;

@IsNotEmpty({ message: "O campo não pode estar vazio." })

 @IsDate({ message: "O campo deve ser uma data válida." })
ordered_at: Date;
}

Componente: Dto (update)

import { PartialType } from '@nestjs/mapped-types';

import { IsInt, IsNotEmpty } from 'class-validator';

import { OrderCreateDto } from './order.create-dto';

export class OrderUpdateDto extends PartialType(OrderCreateDto) {

@IsNotEmpty({message: "O ID não pode estar vazio"})

@IsInt({message: "O dado deve ser convertido para inteiro antes
de ser armazenado."})
id: number
}
Camada: Infrastructure

Componente: Module

import { Module } from "@nestjs/common";

import { PrismaModule } from
"src/Infrastructure/Prisma/prisma.module";

import { OrderService } from

"src/Domain/Services/Market/order.service";
import { PrismaOrderRepository } from
"src/Infrastructure/Repositories/Marketplace/prisma-
order.repository";
import { OrderController } from
"src/Interface/Controllers/Marketplace/order.controller";

import { CreateOrderUseCase } from

"src/Application/use-cases/Marketplace/order/create-order.use-
case";
import { DeleteOrderUseCase } from
"src/Application/use-cases/Marketplace/order/delete-order.use-
case";
import { FindAllOrdersUseCase } from
"src/Application/use-cases/Marketplace/order/find-all-orders.use-
case";
import { UpdateOrderUseCase } from
"src/Application/use-cases/Marketplace/order/update-order.use-
case";
import { FindOrderByIdUseCase } from
"src/Application/use-cases/Marketplace/order/find-order-by-id.use-
case copy";
import { FindOrdersByCustomerUseCase } from "src/Application/use-
cases/Marketplace/order/find-orders-by-customer.use-case";
import { FindOrdersBySellerUseCase } from "src/Application/use-
cases/Marketplace/order/find-orders-by-seller.use-case";

@Module({
imports: [PrismaModule],
exports: [OrderService],
controllers: [OrderController],

providers: [
OrderService,
PrismaOrderRepository,
 CreateOrderUseCase,
UpdateOrderUseCase,
DeleteOrderUseCase,
FindAllOrdersUseCase,
FindOrderByIdUseCase,
FindOrdersByCustomerUseCase,
FindOrdersBySellerUseCase,

{
provide: 'OrderRepository',
useClass: PrismaOrderRepository
}
]
})
export class OrderModule {}
Componente: PrismaRepository

import { Injectable } from "@nestjs/common";

import { PrismaService } from
"src/Infrastructure/Prisma/prisma.service";

import { newOrder, Order } from

"src/Domain/Entities/Market/order.entity";
import { OrderRepository } from
"src/Domain/Repositories/Market/order.repository";

@Injectable()
export class PrismaOrderRepository implements OrderRepository {
constructor(private readonly prisma: PrismaService) { }

async create(order: newOrder): Promise<newOrder> {

const created = await this.prisma.order.create({
data: {
userCostumer: order.userCostumer,
userSeller: order.userSeller,
fkCurrency: order.fkCurrency,
fkOrderStatus: order.fkOrderStatus,
fkShippingAddress: order.fkShippingAddress,
totalAmount: order.totalAmount,
fkCoupon: order.fkCoupon,
createdDt: order.createdDt,
}
});

return new newOrder(

created.userCostumer, created.userSeller,
created.fkCurrency, created.fkOrderStatus,
created.fkShippingAddress,
created.totalAmount.toNumber(),
created.fkCoupon,
created.createdDt,
);
}

async update(order: Order): Promise<Order> {

const updated = await this.prisma.order.update({
where: { id: order.id },
data: {
userCostumer: order.userCostumer,
userSeller: order.userSeller,
fkCurrency: order.fkCurrency,
fkOrderStatus: order.fkOrderStatus,
 fkShippingAddress: order.fkShippingAddress,
fkCoupon: order.fkCoupon,
totalAmount: order.totalAmount,
}
});

return new Order(

updated.id, updated.userCostumer, updated.userSeller,
updated.fkCurrency, updated.fkOrderStatus,
updated.fkShippingAddress, updated.fkCoupon,
updated.totalAmount.toNumber()
)
}

async delete(id: number): Promise<void> {

await this.prisma.order.delete({ where: { id } });
}

async findAll(): Promise<Order[]> {

const orders = await this.prisma.order.findMany();
return orders.map(order => new Order(order.id,
order.userCostumer, order.userSeller, order.fkCurrency,
order.fkOrderStatus, order.fkShippingAddress,
order.totalAmount.toNumber(), order.fkCoupon));
}

async findById(id: number): Promise<Order | null> {

const order = await this.prisma.order.findUnique({ where: {
id } });
return order ? new Order(order.id, order.userCostumer,
order.userSeller, order.fkCurrency, order.fkOrderStatus,
order.fkShippingAddress, order.totalAmount.toNumber(),
order.fkCoupon) : null;
}

async findByCustomer(userCostumer: number): Promise<Order[]> {

const orders = await this.prisma.order.findMany({ where: {
userCostumer } });
return orders.map(order => new Order(order.id,
order.userCostumer, order.userSeller, order.fkCurrency,
order.fkOrderStatus, order.fkShippingAddress,
order.totalAmount.toNumber(), order.fkCoupon));
}

async findBySeller(userSeller: number): Promise<Order[]> {

const orders = await this.prisma.order.findMany({ where: {
userSeller } });
return orders.map(order => new Order(order.id,
order.userCostumer, order.userSeller, order.fkCurrency,
order.fkOrderStatus, order.fkShippingAddress,
order.totalAmount.toNumber(), order.fkCoupon));
}

async findByStatus(fkOrderStatus: number): Promise<Order[]> {

const orders = await this.prisma.order.findMany({ where:
{fkOrderStatus }});
return orders.map(order => new Order(order.id,
order.userCostumer, order.userSeller, order.fkCurrency,
order.fkOrderStatus, order.fkShippingAddress,
order.totalAmount.toNumber(), order.fkCoupon));
}
}