quiz.js

const express = require('express')
const app = express()
app.use(express.json())

const jwt = require('jsonwebtoken')
const { authMiddleWare, SECRET_KEY, adminOnly } = require('./middleware')
const { userModel, QuizModel } = require('./models')
const bcrypt = require('bcrypt')
const {
    signupSchema,
    loginSchema,
    quizSchema,
    questionSchema,
    validate
} = require("./zod")


app.post('/api/auth/signup', validate(signupSchema), async (req, res) => {
    const { name, email, role, password } = req.body;

    if (!name || !email || !role || !password) {
        return res.status(400).json({
            success: false,
            error: "All fields are required"
        })
    }

    const existing = await userModel.findOne({ name })
    if (existing) {
        return res.status(400).json({ message: "User already exists" })
    }

    const hashPass = await bcrypt.hash(password, 12);

    const newUser = await userModel.create({
        name,
        email,
        role,
        password: hashPass
    })

    const token = jwt.sign(
        {
            id: newUser._id,
            name: newUser.name,
            email: newUser.email,
            role: newUser.role
        },
        SECRET_KEY
    )

    res.status(201).json({
        success: true,
        token
    })
})


app.post('/api/auth/login', validate(loginSchema), async (req, res) => {
    const { name, password } = req.body

    if (!name || !password) {
        return res.status(400).json({ message: "Both fields are required" })
    }

    const user = await userModel.findOne({ name })
    if (!user) {
        return res.status(400).json({ message: "User not found" })
    }

    const isValid = await bcrypt.compare(password, user.password)
    if (!isValid) {
        return res.status(400).json({ message: "Wrong password" })
    }

    const token = jwt.sign(
        {
            id: user._id,
            name: user.name,
            email: user.email,
            role: user.role
        },
        SECRET_KEY
    )

    res.json({
        success: true,
        token
    })
})


app.get('/api/auth/me', authMiddleWare, async (req, res) => {
    const user = await userModel.findById(req.userId)
    res.json({ success: true, user })
})


// create new quiz

app.post('/api/quiz', adminOnly, validate(quizSchema), async(req, res) => {
    const {title, questions} = req.body

    if(!title || !Array.isArray(questions) || questions.length == 0){
        return res.status(400).json({
            success: false,
            error: "Invalid request schema"
        })
    }

    for(const q of questions){
        if(!q.text || !Array.isArray(q.options) || typeof q.correctOptionIndex !== Number || q.options.length == 0){
            return res.status(400).json({
                success: false,
                error: "Invalid request schema"
            })
        }
    }

    const newData = await QuizModel.create({
        title,
        questions
    })

    res.status(201).json({
        success: true,
        data: {_id: newData.id, title: newData.title}
    })
})


// create new questions
app.post('/api/quiz/:quizId', adminOnly, validate(questionSchema), async(req, res) => {
    const quizId = req.params.quizId
    const {text, options, correctOptionIndex} = req.body
    if(!text || typeof correctOptionIndex !== Number || !Array.isArray(options) || options.length == 0){
        return res.status(400).json({
            success: false,
            error: "Invalid request schema"
        })
    }

    const Quiz = await QuizModel.findById(quizId)
    if(!Quiz){
        return res.status(404).json({
            success: false,
            error: "Quiz not found"
        })
    }

    const newQuestion = {
        text, 
        options,
        correctOptionIndex
    }
    Quiz.questions.push(newQuestion)
    await Quiz.save()

    res.status(201).json({
        success: true,
        data: {quizId, newQuestion}
    })
})

app.get('api/quiz/:quizId', adminOnly, async(req, res) => {
    const quizId = req.params.quizId
    const Quiz  = await QuizModel.findById(quizId)
    if(!Quiz){
        return res.status(404).json({
            success: false,
            error: "Quiz not found"
        })
    }
    res.status(200).json({
        success: true,
        data: Quiz.questions
    })
})

app.listen(3000)


// const express = require('express')
// const app = express()
// app.use(express.json())

// const {userModel, quizModel} = require('./models')
// const {middleware, SECRET_RANDOM} = require('./middleware')
// const jwt = require('jsonwebtoken')
// const {signupSchema, loginSchema, validate} = require('./zod')
// const bcrypt = require('bcrypt')

// app.post('/signup', validate(signupSchema), async(req, res) => {
//     const {name, password, email, role} = req.body
//     if(!name || !password || !email || !role){
//         return res.status(400).json({
//             success: false,
//             message: "All fields are required"
//         })
//     }

//     const existing = await userModel.fineOne(name)
//     if(existing){
//         return res.status(400).json({
//             success: false,
//             message: "user already exists, please log in"
//         })
//     }

//     const hashPass = await bcrypt.hash(password, 13)

//     const newUser = userModel.create({
//         name,
//         email,
//         role,
//         password: hashPass
//     })

//     const token = jwt.sign({id: newUser._id, email: newUser.email, role: newUser.role, password: newUser.password}, SECRET_RANDOM)

//     res.status(201).json({
//         success: true,
//         token
//     })

// })

// app.post('/login', validate(loginSchema), async(req, res) => {
//     const {name, password} = req.body

//     if(!name || !password){
//         return res.status(400).json({
//             success: false,
//             message: "All fields are required"
//         })
//     }

//     const user = await userModel.findOne(name)

//     if(!user){
//         return res.status(400).json({
//             success: false,
//             message: "user not found"
//         })
//     }

//     const isValid = bcrypt.compare(password, user.password)
//     if(!isValid){
//         return res.status(400).json({
//             success: false,
//             message: "password is not correct"
//         })
//     }

//     const token = jwt.sign({
//         id: user._id,
//         email: user.email,
//         password: user.password,
//         role: user.role
//     }, SECRET_RANDOM)

//     res.status(200).json({
//         success: true,
//         data: token
//     })   

// })

// app.get('/api/auth/me', middleware, async(req, res) => {
//     const user = await userModel.findOne(req.user.id)
//     res.status(200).json({success: true, data: user})
// })


// app.post('api/quiz', adminOnly, async(req, res) => {
    
// })