Thiết kế website giá rẻ

Question

Well, I’m trying to implement an enum in my api, but I always get an error and I’ve tried everything, I always say that my enum is invalid but I don’t see any error in it, does anyone know?

my codes
my reservaEntidade:

import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";
import { UsuarioEntidade } from "./usuario.entity";
enum clientChegou {
    sim = 'sim',
    nao = 'nao'
}
enum Reserva {
    pendente = 'pendente',
    confirmada = 'confirmada',
    estornado = 'estornado',
    negada = 'negada'
}
@Entity({name: 'reserva'})
export class ReservaEntidade {
    @PrimaryGeneratedColumn('uuid')
    id: string

    @Column({name: 'inicio', type: 'date', nullable: false })
    inicio: Date;

    @Column({name: 'fim', type: 'date',nullable: false })
    fim: Date;

    @Column({name: 'idQuartoeSecret', nullable: false})
    idQuartoeSecret: string

    @Column({name: 'clientArrive', type: 'enum', enum: clientChegou, default: clientChegou.nao})
    clientArrive: clientChegou

    @Column({name: 'Reserva', type: 'enum', enum: Reserva })
    Reserva: Reserva;

    @ManyToOne(() => UsuarioEntidade, (usuario) => usuario.reserva, {
        cascade: true, onDelete: 'CASCADE', onUpdate: 'CASCADE'
    })
    usuario: UsuarioEntidade


}

my reservaService:

enum Pago {
  nao = 'nao',
  sim = 'sim',
  estornado = 'estornado'
}
enum Reserva {
  pendente = 'pendente',
  confirmada = 'confirmada',
  estornado = 'estornado',
  negada = 'negada'
}
enum PagamentoCartao {
  cartao_credeb = 'credeb',
  teste1 = 'teste1',
  teste2 = 'teste2'
}
enum clientChegou {
  sim = 'sim',
  nao = 'nao'
}
enum QuartoDisponivel {
  sim = 'sim',
  nao = 'nao'
}
@Injectable()
export class ReservaService {
  constructor(
    @InjectRepository(ReservaEntidade)
    private readonly reservaRepository:Repository<ReservaEntidade>,
    @InjectRepository(UsuarioEntidade)
    private readonly usuarioRepository:Repository<UsuarioEntidade>,
    @InjectRepository(QuartoEntidade)
    private readonly quartoRepository:Repository<QuartoEntidade>,
    @InjectRepository(PagamentoEntidade)
    private readonly pagamentoRepository:Repository<PagamentoEntidade>,
    private readonly metodosAcharId: AcharMetodos
    
  ){}
  
  async criaReservaQuarto(idUsuario: string, idQuarto: string, dados: CriaReservaDTO){

    const usuarioPagamento = await this.metodosAcharId.acharUsuario(idUsuario)
    
    const quartoPagamento = await this.metodosAcharId.acharQuarto(idQuarto)
    console.log(idQuarto)
    if(quartoPagamento === null){
      throw new NotFoundException('Quarto nao achado')
    }
    if(quartoPagamento.disponivel === QuartoDisponivel.nao){
      throw new UnauthorizedException('Quarto nao disponivel para reserva')
    }


    const pagamentoEntidade = new PagamentoEntidade()
    pagamentoEntidade.id = randomUUID()
    pagamentoEntidade.usuario = usuarioPagamento
    pagamentoEntidade.usuarioPagamento = usuarioPagamento.nome
    pagamentoEntidade.StatusPago = Pago.nao
    pagamentoEntidade.valor = quartoPagamento.preco
    pagamentoEntidade.idQuartoeSecret = quartoPagamento.id
    pagamentoEntidade.pagamentoDoCartao = PagamentoCartao.cartao_credeb
    const dataS = new Date()
    dataS.setUTCHours(dataS.getUTCHours() - 3)
    const dataAtual = dataS.toISOString()
    pagamentoEntidade.data_pagamento = dataAtual  

  
    const reservaEntidade = new ReservaEntidade()
    reservaEntidade.id = randomUUID()
    reservaEntidade.usuario = usuarioPagamento
    //const data = new Date()
    reservaEntidade.inicio = dados.inicio
    reservaEntidade.fim = dados.fim
    reservaEntidade.Reserva = Reserva.pendente
    reservaEntidade.idQuartoeSecret = quartoPagamento.id
    reservaEntidade.clientArrive = clientChegou.nao
  
    const usuarioFIN = {
      email: usuarioPagamento.email,
      name: usuarioPagamento.nome,
      address: {
        line1: 'Existe, 123',
        city: usuarioPagamento.pais,
        postal_code: '12345',
        country: 'BR', // Código do país (ISO 3166-1 alpha-2)
      },
    };
    const valorApagar = pagamentoEntidade.valor * 100
    const novoPreco = await stripe.prices.create({
      unit_amount: valorApagar, 
      currency: 'BRL', 
      product_data: {
          name: 'Quarto', 
          
      },
  });
  
  const pagamentoTT = await stripe.paymentIntents.create({
    amount: valorApagar, // Defina o valor do pagamento aqui
    currency: 'BRL', // Defina a moeda do pagamento aqui
    metadata: {
        user_id: usuarioPagamento.id // Aqui está o ID do usuário como metadado
    }
  });
    //const precoS = quartoPagamento.preco.toString()
      // Criar sessão de checkout
      const session = await stripe.checkout.sessions.create({
        line_items: [{ price: novoPreco.id, quantity: 1 }],
        mode: 'payment',
        payment_intent_data: {
          setup_future_usage: 'on_session', 
        },   
        customer_email: usuarioFIN.email,
        client_reference_id: usuarioFIN.name,
        success_url: 'http://localhost:4000/pay/success/checkout/session?session_id={CHECKOUT_SESSION_ID}',
        cancel_url: 'http://localhost:4000/pay/failed/checkout/session',
        metadata: {
          payment_id: usuarioPagamento.id
        }
      });
      pagamentoEntidade.urlPayment = session.url
      pagamentoEntidade.idReservaSecret = reservaEntidade.id
      pagamentoEntidade.idPagamentoSK = session.id
      session.payment_intent = pagamentoTT
      console.log( session)
  

    return Promise.all([
        this.usuarioRepository.save(usuarioPagamento),
        this.reservaRepository.save(reservaEntidade),
        this.pagamentoRepository.save(pagamentoEntidade)
    ])

  }
  
  async confirmarPagamento(idUsuario: string, idPagamento: string, idReserva: string){

    const usuario = await this.metodosAcharId.acharUsuario(idUsuario)
    if( usuario === null){
      throw new NotFoundException('Usuario nao achado')
    }
    
    const pagamento = await this.metodosAcharId.acharPagamento(idPagamento)
    if( pagamento === null){
      throw new NotFoundException('Pagamento nao achado')
    }

    const idQuarto = pagamento.idQuartoeSecret
    const Quarto = await this.metodosAcharId.acharQuarto(idQuarto)
    if( Quarto === null){
      throw new NotFoundException('Quarto nao achado')
    }
    if(pagamento.StatusPago === Pago.sim){
      throw new NotFoundException('Pagamento ja confirmado')
    }
    // if(Quarto.disponivel === QuartoDisponivel.sim && pagamento.idQuartoeSecret === Quarto.id ){
    //   throw new NotFoundException('Voce ja confirmou o pagamento :)')
    // }
    const reserva = await this.reservaRepository.findOne({where: {id: idReserva}})
    if( reserva === null){
      throw new NotFoundException('Reserva nao achado')
    }
    if(reserva.Reserva === Reserva.confirmada){
      throw new NotFoundException('Reserva ja confirmada para um quarto')
    }
    if(Quarto.disponivel === QuartoDisponivel.nao){
      throw new UnauthorizedException('Quarto nao disponivel para reserva')
    }
    if(pagamento.idReservaSecret !== reserva.id){
      throw new NotFoundException('Pagamento nao foi gerado para essa reserva')
    }
    const compraP = await stripe.checkout.sessions.retrieve(pagamento.idPagamentoSK)
    const paY = compraP.payment_intent
    //const remmB = await stripe.refunds.create({payment_intent: paY.toString()})
    console.log(paY)
    if(compraP.metadata.payment_id !== usuario.id){
      console.log()
      throw new UnauthorizedException('Voce nao gerou esse pagamento')
    }
   
    console.log(compraP.payment_status)
    if(compraP.payment_status === 'paid' && compraP.status === 'complete'){
      console.log('pagado joia')
      reserva.Reserva = Reserva.confirmada
      pagamento.StatusPago = Pago.sim
      Quarto.disponivel = QuartoDisponivel.nao
      await this.quartoRepository.save(Quarto)
      await this.reservaRepository.save(reserva),
      await this.pagamentoRepository.save(pagamento)
      return Promise.all([
        await this.usuarioRepository.save(usuario),
      ])
    }else {
      throw new UnauthorizedException(`pagou nao :(, compra em aberto, preco a pagar: ${pagamento.valor}`)
    }
    
  }

  async fazerReembolso(idUsuario: string, idPagamento: string){
    const usuarioR = await this.metodosAcharId.acharUsuario(idUsuario)
    const pagamento = await this.metodosAcharId.acharPagamento(idPagamento)
    
    const secao = await stripe.checkout.sessions.retrieve(pagamento.idPagamentoSK)
    if(secao.metadata.payment_id !== usuarioR.id){
      console.log()
      throw new UnauthorizedException('Voce nao gerou esse pagamento')
    }
    const quarto = await this.quartoRepository.findOne({where: {id: pagamento.idQuartoeSecret}})
    if(quarto.disponivel === QuartoDisponivel.nao){
      quarto.disponivel = QuartoDisponivel.sim
    }else{
      throw new UnauthorizedException('Ocorreu um erro!')
    }
    const reserva = await this.reservaRepository.findOne({where: {id: pagamento.idReservaSecret}})
    if(reserva.clientArrive === clientChegou.sim){
      throw new UnauthorizedException('Cliente nao pode reembolsar apos usar o quarto!')
    }
    if(pagamento.StatusPago === Pago.nao){
      throw new UnauthorizedException('Pagamento nao foi reembolsado, pagamento ainda nao concluido ou pago para fazer o reembolso')
    }
    reserva.Reserva = Reserva.estornado
    pagamento.StatusPago = Pago.estornado
    const payS = secao.payment_intent
    await stripe.refunds.create({payment_intent: String(payS)})
    await this.quartoRepository.save(quarto)
    await this.reservaRepository.save(reserva)
    await this.pagamentoRepository.save(pagamento)

    return pagamento
  }

obs: the function criaReservaQuarto, Create a reservation and the payment will be saved as pending, when the payment is paid in the url generated by stripe, it will go to the function confirmarPagamento (confirmPayment) which will check if payment has been made and will confirm, changing the reservation to confirmed and payment to paid, and room to unavailable, but in fazerReembolso, It will check if the payment was made and will refund the money, but it is going wrong, saying that the reservation enum “Reserva” is inserting an invalid value, but I can’t see where the error is.

the error log:

[Nest] 30  - 05/15/2024, 5:34:46 PM   ERROR [RpcExceptionsHandler] invalid input value for enum pagamento_statuspago_enum: "estornado"
nestor-1          | QueryFailedError: invalid input value for enum pagamento_statuspago_enum: "estornado"

Thiết kế website giá rẻ

Danh mục

invalid input value for enum?, but I have tried everything