Creación de un endpoint que obtengamos una pregunta tipo test de forma aleatória

omiras commented 2 days ago

Objetivo

Crear un endpoint /api/v1/questions/random

Ánalisis

Inicializar un proyecto con NPM
Subir el proyecto a GitHub
Instlar las dependencias necesarias
Necesitamos crear un nuevo endpoint
Necesitamos acceso a una base de datos de MongoDB (MongoDB Atlas)
1. Necesitamos crear una cuenta en MongoDB Atlas y configurarla correctamente
Crear una cuenta de correo para los servicios de MongoDB Atlas para Render.com. Crear una cuenta de GMAIL u otros servicio correo y compartir las claves de acceso en el grupo de Slack #proyecto-final
Crear un modelo de Mongoose para almacenar las preguntas tipo test
- ¿Cómo almacenar las 4 respuestas posible? ¿Array de strings?
- ¿Cómo marcamos la respuesta correcta?
Insertar al menos 10 pregunas tipo test
Variables de entorno. Parece ser que ahora NodeJS no requiere de instalar el módulo dotenv. ¡Podemos probar si queréis! - enlace

Cómo probar la issue

Debemos explicar a nuestros compañeros como pueden probar que la tarea funciona. ¿Que pasos deben seguir? Recordad que los pantallazos con la salida por ejemplo de Thnder Client pueden ser muy útiles para clarificar que es lo que tiene que pasar - screenshot

Adicionalmente, podéis crear un par de tests para probar el endpoint tal y como hicimos en clase - enlace

omiras commented 1 day ago

¿Que estructura pensáis que debería tener una pregunta tipo test? Podéis dar un ejemplo usando un objeto de JavaScript o directamente un modelo de Mongoose.

crimanlor commented 1 day ago

Una posible opción, sería que el esquema "Question" tuviera los siguientes campos:

Description: corresponde al texto de la pregunta.
Options: a cada una de las posibles respuestas.
Category: tipología de la pregunta.
Level: nivel de dificultad de cada pregunta.

CreatedAt: para llevar un registro de qué preguntas están más actualizadas.

const questionSchema = new mongoose.Schema({
description: {
type: String,
required: true,
},
options: [
{
  label: {
    type: String,
    enum: ['a', 'b', 'c', 'd'],
    required: true,
  },
  text: {
    type: String,
    required: true,
  },
  isCorrect: {
    type: Boolean, 
    default: false,
  }
}
],
category: {
type: String,
required: true,
},
level: {
type: String,
enum: ['easy', 'medium', 'hard'],
default: 'medium',
},
createdAt: {
type: Date,
default: Date.now,
},
});

kevmhughes commented 1 day ago

Quizás podríamos usar la opción nativa de Mongoose para gestionar automáticamente la creación y actualización de los documentos: { timestamps: true }.

Al habilitar { timestamps: true } en la configuración del esquema, Mongoose automáticamente añade y gestiona dos campos:

createdAt: que almacena la fecha y hora en que se creó el documento. updatedAt: que se actualiza automáticamente cada vez que se modifica el documento.

const questionSchema = new mongoose.Schema({
  description: {
    type: String,
    required: true,
  },
  options: [
    {
      label: {
        type: String,
        enum: ['a', 'b', 'c', 'd'],
        required: true,
      },
      text: {
        type: String,
        required: true,
      },
      isCorrect: {
        type: Boolean,
        default: false,
      },
    },
  ],
  category: {
    type: String,
    required: true,
  },
  level: {
    type: String,
    enum: ['easy', 'medium', 'hard'],
    default: 'medium',
  },
}, { timestamps: true });

kevmhughes commented 1 day ago

Sugiero otros campos que podrían añadirse al esquema que ha sugerido Lorena.

const questionSchema = new mongoose.Schema({
  description: {
    type: String,
    required: true,  // Main question text
  },
  codeSnippet: {
    type: String,    // Optional code snippet relevant to the question
    required: false,
  },
  options: [
    {
      label: {
        type: String,
        enum: ['a', 'b', 'c', 'd'],  // Option labels, constrained to four choices
        required: true,
      },
      text: {
        type: String,  // The actual option text
        required: true,
      },
      isCorrect: {
        type: Boolean,  // Indicates if the option is correct
        default: false,
      }
    }
  ],
  explanation: {
    correct: {
      type: String,  // Explanation for why the correct option is right
      required: false,
    },
    incorrect: {
      type: String,  // General explanation for why other options are wrong
      required: false,
    }
  },
  tags: {
    type: [String],  // List of relevant programming topics or concepts (e.g., 'JavaScript', 'OOP', 'Recursion')
    required: false,
  },
  language: {
    type: String,  // The programming language related to the question (e.g., 'JavaScript', 'Python')
    required: true,
  },
  level: {
    type: String,
    enum: ['easy', 'medium', 'hard'],  // Difficulty level of the question
    default: 'medium',
  },
}, { timestamps: true });  // Automatically add createdAt and updatedAt

MariaChmielinska commented 1 day ago

Yo añadiría también la tecnología y el idioma. No se si Lorena con category quiere decir Dev Category como Front End, BackEnd?

  tech: {
    type: String,
    enum: ['python', 'css', 'java script', etc.],
    required: true,
  },
  language: {
    type: String,
    enum: ['english', 'german', 'spanish', etc.],
    required: true,
  },

ekbalam11 commented 1 day ago

Mi respuesta

const pregunta = {
    id: {
        type: Number
    },
    enunciado: {
        type: String
    }, //la pregunta como tal
    tema: {
        type: String,
        enum: ['Aquí van los tags']
    }, //una especie de tag
    respuestas: {
        opcion1,
        opcion2,
        opcion3,
        opcionEtc
    },
    explicación: {
        type: String
    },
    lenguaje: {
        type: String,
        enum: ['python', 'etc'] //lista de lenguajes posibles
    },
    source: {
        type: String,
        //Fuente de información de donde se obtuvo la respuesta
 }

SharmarAndrey commented 1 day ago

¿Que estructura pensáis que debería tener una pregunta tipo test? Podéis dar un ejemplo usando un objeto de JavaScript o directamente un modelo de Mongoose.


// Ejemplo de objeto JavaScript
const testQuestion = {
questionText: '¿Question ?', // Texto de la pregunta
options: [
{ text: 'a', isCorrect: false }, // Opción de respuesta: texto e indicación de si es la respuesta correcta
{ text: 'b', isCorrect: true },
{ text: 'c', isCorrect: false },
{ text: 'd', isCorrect: false }
],
difficulty: 'fácil', // Nivel de dificultad de la pregunta 
category: 'Java Script', // Categoría de la pregunta 
explanation: 'explicacion de la respuesta' // Explicación de la respuesta correcta
};

// Función para mezclar las opciones de respuesta function shuffleOptions(question) { question.options = question.options.sort(() => Math.random() - 0.5); }

shuffleOptions(testQuestion); console.log(testQuestion);

// Ejemplo de modelo Mongoose const mongoose = require('mongoose');

const QuestionSchema = new mongoose.Schema({ questionText: { type: String, required: true // Texto de la pregunta }, options: [ { text: { type: String, required: true // Texto de la opción de respuesta }, isCorrect: { type: Boolean, required: true // Indicación de si esta opción de respuesta es correcta } } ], difficulty: { type: String, enum: ['fácil', 'medio', 'difícil'], // Nivel de dificultad required: true // Campo obligatorio }, category: { type: String, required: true // Categoría de la pregunta (por ejemplo, Java Script) }, explanation: { type: String // Explicación de la respuesta correcta } });

const Question = mongoose.model('Question', QuestionSchema);

module.exports = Question;

omiras commented 16 hours ago

Buen trabajo a todos los qe habéis pensado el mejor modelo de datos. Recordad al implementar vuestro modelo de Mongoose el lema :

“Always implement things when you actually need them, never when you just foresee that you need them.”

MariaChmielinska commented 7 hours ago

email address: codequestapi@gmail.com pw: IronHack2024

omiras commented 5 hours ago

email address: codequestapi@gmail.com pw: IronHack2024

Esto es mejor que no esté aquí, solo en Slack. Porque el proyecto es publico y cualquiera puede ver las credenciales ;)

omiras commented 4 hours ago

¿Que estructura pensáis que debería tener una pregunta tipo test? Podéis dar un ejemplo usando un objeto de JavaScript o directamente un modelo de Mongoose.

// Ejemplo de objeto JavaScript
const testQuestion = {
  questionText: '¿Question ?', // Texto de la pregunta
  options: [
    { text: 'a', isCorrect: false }, // Opción de respuesta: texto e indicación de si es la respuesta correcta
    { text: 'b', isCorrect: true },
    { text: 'c', isCorrect: false },
    { text: 'd', isCorrect: false }
  ],
  difficulty: 'fácil', // Nivel de dificultad de la pregunta 
  category: 'Java Script', // Categoría de la pregunta 
  explanation: 'explicacion de la respuesta' // Explicación de la respuesta correcta
};

// Función para mezclar las opciones de respuesta
function shuffleOptions(question) {
  question.options = question.options.sort(() => Math.random() - 0.5);
}

shuffleOptions(testQuestion);
console.log(testQuestion);

// Ejemplo de modelo Mongoose
const mongoose = require('mongoose');

const QuestionSchema = new mongoose.Schema({
  questionText: {
    type: String,
    required: true // Texto de la pregunta
  },
  options: [
    {
      text: {
        type: String,
        required: true // Texto de la opción de respuesta 
      },
      isCorrect: {
        type: Boolean,
        required: true // Indicación de si esta opción de respuesta es correcta 
      }
    }
  ],
  difficulty: {
    type: String,
    enum: ['fácil', 'medio', 'difícil'], // Nivel de dificultad 
    required: true // Campo obligatorio
  },
  category: {
    type: String,
    required: true // Categoría de la pregunta (por ejemplo, Java Script)
  },
  explanation: {
    type: String // Explicación de la respuesta correcta 
  }
});

const Question = mongoose.model('Question', QuestionSchema);

module.exports = Question;

@crimanlor conoce una forma de obtener un documento aleatorio de una colección de MongoDB usando un "aggregate". Quizás podríais utilizarlo para vuestro endpoint

SharmarAndrey commented 2 minutes ago


1. Hay que cambiar en modelo "require" por "required", para todos los campos;
2.  Linea 39 "return: Array.length(-4)" no va a funcionar, porque return no es un campo valido de mogoose. Hay que implementar validacion. Creo que Oscar ha esplicado este en un clase(que podemos anadir validacion a eschema)
3. Para trabajar mas comodo hay que anadir a "pakage.json", dentro del campo "scripts " esta linea:  "dev": "nodemon app.js", pero antes istalar "nodemon";
4. hay que importar con "require" nuestra Eschema de mongoose, a app.js;
5. Hay que anadir  midelware "app.use(express.json());", para trabajar con JSON;
6. Por que sale "exports.postQuestion" en app.js?   Supongo que es un error y hay que poner "const postQuestion" ?
7. No emos  definido la ruta para hacer POST (app.post('/api/v1/questions', postQuestion);  
8. Hay que preguntar si metemos doto codigo a app.js o creamos carpetas para rutas, controllers e.t.c.
9.  nosotrros tenemos en modelo "const Question = model('question', questionSchema);" Y pasamos dentro de modelo eschema con minuskula, pero requerdo que he preguntado Oscar, en un clase y el ha dicho que hay aquerdo dentro programadores para defenir Modelos con letra Mauscula, para saber que no es funcion normal(no estoy seguro =)). 
10.  Hay que buscara como funciona "aggregate", que mencionado Oscar o preguntar Lorena .

IronHack-2024 / CodeQuestAPI