En la clase anterior vimos como puedes hacer para identificar un rol y de acuerdo a eso poder darle acceso a un endpoint, ahora te pongo el siguiente escenario:
¿Como crear un endpoint que retorne todas las órdenes relacionados con el usuario que tiene sesión?
Una solución válida a este problema es que puedes crear un endpoint que enviándole el ID de un usuario te retorne dichas órdenes, algo como esto:
http://localhost:3000/users/1/orders
Este endpoint me retornaría todas las órdenes del usuario con ID 1, sin embargo puede ser algo peligroso, es decir, este endpoint solo debería estar disponible para los roles administrativos, pero no para los usuarios porque si conoces el ID de algún cliente podrías obtener la información de órdenes de compra de un usuario.
La solución más práctica para este caso es crear un endpoint de este tipo:
http://localhost:3000/profile/my-orders
Como ves en el endpoint anterior no estás colocando de forma explícita el ID de un usuario. ¿Entonces como sabe a qué usuario le pertenecen las órdenes? Sencillo, sí nuestro usuario ya tiene una sesión, esta información ya está en el JWT que se le otorgó a ese usuario al autentificarse en el sistema así con eso podemos inferirlo de acuerdo a la sesión
Ok, ok, cerebrito, suena bien pero, ¿y el código...? Vamos a iniciar con ello. Lo primero es que vamos a hacer es crear un nuevo controlador para todos las solicitudes que sean de este tipo. Lo vamos a crear con el nombre ProfileController.
nest g co users/controllers/profile --flat
Allí vamos a exponer un nuevo endpoint que va a recibir la solicitud y gracias al decorador de
@UseGuards(JwtAuthGuard, RolesGuard) nos aseguramos que tenga un token válido, así que en ese método recogemos la información de usuario que tiene esa sesión así:
@Roles(Role.CUSTOMER) @Get('my-orders') getOrders(@Req() req: Request) { const user = req.user as PayloadToken; return this.orderService.findOne(user.sub); }
Simplemente con decirle que dentro del método que queremos la información del Request podemos obtener la información del usuario que tiene sesión, luego simplemente obtenemos el ID y ya con eso podemos crear un método en nuestro servicio de órdenes que las retorne, algo así:
ordersByCustomer(customerId: number) { return this.orderRepo.find({ where: { customer: customerId, }, }); }
Este sería el código completo del nuevo controlador ProfileController:
import { Controller, Get, UseGuards, Req } from '@nestjs/common'; import { ApiTags } from '@nestjs/swagger'; import { Request } from 'express'; import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard'; import { RolesGuard } from '../../auth/guards/roles.guard'; import { Roles } from '../../auth/decorators/roles.decorator'; import { Role } from '../../auth/models/roles.model'; import { PayloadToken } from 'src/auth/models/token.model'; import { OrdersService } from '../services/orders.service'; @UseGuards(JwtAuthGuard, RolesGuard) @ApiTags('profile') @Controller('profile') @Controller('profile') export class ProfileController { constructor(private orderService: OrdersService) {} @Roles(Role.CUSTOMER) @Get('my-orders') getOrders(@Req() req: Request) { const user = req.user as PayloadToken; return this.orderService.ordersByCustomer(user.sub); } }
Puedes ver toda esta solución en la rama 14.
A mi no me traía las ordenes del cliente, debido a que el JWT el sub viene firmado con el id del usuario y no del customer. Mi solución fue la siguiente: Inyecté el repositorio de usuario en el constructor de OrdersService:
@InjectRepository(User) private userRepo: Repository<User>,
Luego modifiqué el método de la lectura de la siguiente manera:
async ordersByCustomer(userId: number) { const customerId = (await this.userRepo.findOne(userId,{relations: ["customer"]})).customer.id; return this.orderRepo.find({ where: { customer: customerId, }, relations: ['items', 'items.product'], }); }
Y así ya me trae las ordenes de mi cliente y con sus respectivos productos por orden.
Espero les ayude en algo. Excelente curso!
Carmelo Buelvas Comas
Nicolas Molina
ProfesorHola, genial aporte aunque había un error en la lectura que ya está corregido gracias a tu aporte.
Realmente en OrdersService debería hacer uso de find para obtener todas las órdenes relacionadas con el usuario y no solo una
Italo Fernando Bejarano Gonzales
¿Sería mala práctica agregar el customerId en el payload?
Andres Prieto
Si
David Bryan Arias Castro
async ordersByCustomer(userId: number) { const customerId = ( await this.userRepo.findOne({ relations: ['customer'], where: { id: userId }, }) ).customer.id; return this.orderRepo.find({ where: { **customer**: customerId, }, relations: ['items', 'items.product'], }); }
Tengo este error en el customer:
Type 'number' is not assignable to type 'boolean | FindOperator<any> | FindOptionsWhere<Customer> | FindOptionsWhere<Customer>[] | EqualOperator<Customer>'.
Juan Camilo Noreña López
Gabriel Rodriguez
El método del servicio está mal y no retornará nunca nada. La solución es la siguiente
ordersByCustomer(customerId: number) { return this.orderRepo.find( { customer: customerId } ); //👈🏻 acá está el problema }
Ya que el 'orderRepo' está tipado con el modelo de Order. Entonces hay que indicarle que filtre por alguno de estos parámetros. En nuestro caso queremos que traiga todas las órdenes del customer que haga la petición(recuerden que el id viene vía JWT)
@Schema() export class Order extends Document{ @Prop({type: Date}) date: Date; @Prop({type: Types.ObjectId, ref: Customers.name, required: true}) customer: Customers | Types.ObjectId; @Prop({type: [{type: Types.ObjectId, ref: Product.name}]}) products: Types.Array<Product>; }
Pablo Lionel Benitez
Christian Guevara
Juan Camilo Noreña López
De donde viene el @ExcludeProperty() ??
Joao Villamore
Para realizar una consulta anidada es mejor utilizar:
return this.orderRepo.find({ where: { customer: { id: customerId, }, }, relations: ['customer'], }); ```En vez de realizar la consulta por separado, espero les sirva
Comparto el codigo para MongoDB
PayloadToken
export interface PayloadToken { role: string; sub: string; }
AuthService
generateJWT(user: User) { const payload: PayloadToken = { role: user.role, sub: user._id }; return { access_token: this.jwtService.sign(payload), user, }; }
ProfileController
@Roles(Role.CUSTOMER) @Get('my-orders') getOrders(@Req() req: Request) { const user = req.user as PayloadToken; return this.orderService.ordersByUser(user.sub); }
OrdersService
async ordersByUser(customer: string) { return await this.orderModel.findOne({customer}).exec(); }
Hola mira lo puedes hacer asi:
async ordersByCustomer(userId: number) { const user = await this.userRepo.findOne({ where: { id: userId }, relations: ['customer'], }); const customerId = user.customer.id; return await this.orderRepo.find({ where: { customer: { id: customerId } }, }); }
Decorador:
// auth/current-user.decorator.ts import { createParamDecorator, ExecutionContext, PreconditionFailedException, } from '@nestjs/common'; export const CurrnetUser = createParamDecorator( (_: unknown, ctx: ExecutionContext) => { const request = ctx.switchToHttp().getRequest(); const { user } = request; if (!user) { throw new PreconditionFailedException('User not authenticated.'); } return user; }, );
Uso:
// user/profile.controller.ts // ... agrega UseGuards(JwtAuthGuard)... @UseGuards(JwtGuard, RolesGuard) @Controller('profile') export class ProfileController { // ... en el método de tu controlador, hacer: .. @Get() myMethod(@CurrentUser() user: PayloadToken) { return this.myService.findOne(user.sub); } }
:)
Para mongo:
Para realizar este ejercicio hay un error de logica, primero deben agregar el objeto de "Customer" como propiedad referenciada, es una relacion 1:1 asi que no hay problema.
// user.entity.ts @Schema() export class User extends Document { @Prop({ required: true }) name: string; @Prop({ required: true, unique: true }) email: string; @ExcludeProperty() @Prop({ required: true }) password: string; @Prop({ required: true }) role: string; @Prop({ type: Types.ObjectId, ref: Customer.name, required: true }) customer: Customer | Types.ObjectId; // relacion 1:1 referenciada }
La estructura del controlador no tiene errores asi que esta todo en orden, pero la consulta la debemos cambiar porque en si establecimos una relacio en el paso anterior hasta ahora:
// order.service.ts async ordersByCustomer(userId: string) { /*Nos traemos el usuario debido a que es quien contiene la referencia del customer.*/ const user = await (await this.userService.getUser(userId)).toJSON(); /*Hacemos la consulta en base al customer ID*/ return await this.orderModel // como el id es un objeto debemos transformarlo a un string para poder comparar, sino da error. .find({ customer: user.customer._id.toString() }) .populate('products') // populamos la consulta .exec(); }
Puede que tengan un error de tipado, esto es debido a que el sub de nuestro PayloadToken es de tipo number y los "Id" de mongo son ObjectId o Strings, asi que debemos cambiarlo tambien:
// token.model.ts export interface PayloadToken { role: string; sub: string; }
Espero que les halla funcionado.
