📌 Rota `route.ts`

Este arquivo define a lógica para verificar as respostas de exercícios dentro de cursos. Ele recebe uma requisição POST contendo os dados do exercício e verifica se a resposta enviada está correta.

🔹 Importações

import { NextResponse } from 'next/server' 
import { getPayloadHMR } from '@payloadcms/next/utilities'
import payloadConfig from '@/payload.config'

NextResponse: Usado para retornar respostas HTTP padronizadas.
getPayloadHMR: Obtém a instância do Payload CMS em modo de Hot Module Reload (HMR).
payloadConfig: Importa a configuração do Payload CMS.

📥 Interface dos dados recebidos

interface VerificarRespostaBody {
  cursoId: string
  exercicioId: string
  alternativaId?: string
  respostas?: Array<{ alternativaId: string; resposta: string }>
  blockType: string
}

Essa interface define os parâmetros esperados no corpo da requisição:
✅ cursoId → Identificador do curso.
✅ exercicioId → Identificador do exercício.
✅ alternativaId (opcional) → ID da alternativa escolhida.
✅ respostas (opcional) → Array de respostas para questões do tipo verdadeiro ou falso.
✅ blockType → Define o tipo de exercício (perguntaObjetiva ou verdadeiroOuFalso).

🔍 Lógica principal

export async function POST(request: Request) {
  const { cursoId, exercicioId, alternativaId, respostas, blockType } =
    (await request.json()) as VerificarRespostaBody

📌 Primeiro, a requisição JSON é lida e os parâmetros necessários são extraídos.

🚀 Obtendo o curso e os módulos

const payload = await getPayloadHMR({ config: payloadConfig })
 
if (!payload) {
  console.error('Payload não foi inicializado corretamente.')
  return NextResponse.json({ error: 'Erro interno do servidor' }, { status: 500 })
}

💡 O Payload CMS é carregado para permitir acesso aos dados do curso. Se a inicialização falhar, retorna um erro.

const curso = await payload.findByID({
  collection: 'cursos',
  id: cursoId,
  depth: 10,
})
 
if (!curso || !curso.modulos) {
  return NextResponse.json({ error: 'Curso ou módulos não encontrados' }, { status: 404 })
}

📚 Aqui, buscamos o curso pelo cursoId.
⚠️ Se o curso ou seus módulos não existirem, um erro 404 será retornado.

🔎 Buscando o exercício correto

let exercicioEncontrado: any = null
 
curso.modulos.forEach((moduloObj: any) => {
  const modulo = moduloObj.modulo
  modulo.aulas.forEach((aulaObj: any) => {
    const aula = aulaObj.aula
    if (aula.exercicios && aula.exercicios.length > 0) {
      aula.exercicios.forEach((exercicio: any) => {
        if (exercicio.id === exercicioId) {
          exercicioEncontrado = exercicio
        }
      })
    }
  })
})

📌 Percorre a estrutura de módulos → aulas → exercícios para encontrar o exercício pelo exercicioId.

🎯 Verificando a resposta

let isCorrect: boolean
 
try {
  if (blockType === 'perguntaObjetiva') {
    isCorrect = verificarRespostaPerguntaObjetiva(exercicioEncontrado, alternativaId)
  } else if (blockType === 'verdadeiroOuFalso') {
    isCorrect = verificarRespostaVerdadeiroOuFalso(exercicioEncontrado, respostas)
  } else {
    throw { status: 400, message: 'Tipo de exercício inválido' }
  }
} catch (err: any) {
  return NextResponse.json({ error: err.message }, { status: err.status })
}

📝 Aqui, o código verifica o tipo de questão e chama a função de validação correspondente:
✅ perguntaObjetiva → Chama verificarRespostaPerguntaObjetiva.
✅ verdadeiroOuFalso → Chama verificarRespostaVerdadeiroOuFalso.
⚠️ Se o blockType for inválido, retorna um erro 400.

✅ Função para verificar pergunta objetiva

function verificarRespostaPerguntaObjetiva(
  exercicio: any,
  alternativaId: string | undefined,
): boolean {
  if (!alternativaId) {
    throw { status: 400, message: 'Alternativa não fornecida' }
  }
 
  const alternativaSelecionada = exercicio.alternativas.find(
    (opcao: any) => opcao.id === alternativaId,
  )
 
  if (!alternativaSelecionada) {
    throw { status: 404, message: 'Alternativa não encontrada' }
  }
 
  return alternativaSelecionada.isCorrect
}

📌 Passos:
1️⃣ Verifica se alternativaId foi fornecido.
2️⃣ Procura a alternativa na lista do exercício.
3️⃣ Retorna true se a alternativa estiver correta.

✅ Função para verificar verdadeiro ou falso

function verificarRespostaVerdadeiroOuFalso(
  exercicio: any,
  respostas: Array<{ alternativaId: string; resposta: string }> | undefined,
): boolean {
  if (!respostas || !Array.isArray(respostas)) {
    throw { status: 400, message: 'Respostas não fornecidas ou em formato inválido' }
  }
 
  return respostas.every((respostaObj) => {
    const alternativa = exercicio.alternativas.find(
      (opcao: any) => opcao.id === respostaObj.alternativaId,
    )
    if (!alternativa) {
      throw { status: 404, message: 'Alternativa não encontrada' }
    }
    return respostaObj.resposta === alternativa.valor
  })
}

📌 Passos:
1️⃣ Verifica se respostas é um array válido.
2️⃣ Para cada resposta, compara com a alternativa correta.
3️⃣ Retorna true se todas as respostas estiverem corretas.

🔚 Código Completo

import { NextResponse } from 'next/server' 
import { getPayloadHMR } from '@payloadcms/next/utilities'
import payloadConfig from '@/payload.config'
 
interface VerificarRespostaBody {
  cursoId: string
  exercicioId: string
  alternativaId?: string
  respostas?: Array<{ alternativaId: string; resposta: string }>
  blockType: string
}
 
export async function POST(request: Request) {
  const { cursoId, exercicioId, alternativaId, respostas, blockType } =
    (await request.json()) as VerificarRespostaBody
 
  try {
    const payload = await getPayloadHMR({ config: payloadConfig })
 
    if (!payload) {
      console.error('Payload não foi inicializado corretamente.')
      return NextResponse.json({ error: 'Erro interno do servidor' }, { status: 500 })
    }
 
    const curso = await payload.findByID({
      collection: 'cursos',
      id: cursoId,
      depth: 10,
    })
 
    if (!curso || !curso.modulos) {
      return NextResponse.json({ error: 'Curso ou módulos não encontrados' }, { status: 404 })
    }
 
    let exercicioEncontrado: any = null
 
    curso.modulos.forEach((moduloObj: any) => {
      const modulo = moduloObj.modulo
      modulo.aulas.forEach((aulaObj: any) => {
        const aula = aulaObj.aula
        aula.exercicios?.forEach((exercicio: any) => {
          if (exercicio.id === exercicioId) exercicioEncontrado = exercicio
        })
      })
    })
 
    if (!exercicioEncontrado) {
      return NextResponse.json({ error: 'Exercício não encontrado' }, { status: 404 })
    }
 
    let isCorrect = blockType === 'perguntaObjetiva'
      ? verificarRespostaPerguntaObjetiva(exercicioEncontrado, alternativaId)
      : verificarRespostaVerdadeiroOuFalso(exercicioEncontrado, respostas)
 
    return NextResponse.json({ isCorrect }, { status: 200 })
  } catch (error) {
    return NextResponse.json({ error: 'Erro interno do servidor' }, { status: 500 })
  }
}

route.ts route.ts

📌 Rota route.ts