router-admin.ts

import express from 'express';
import {StatusCodes} from 'http-status-codes';
import {User} from '../database/models/User'

import {Question} from '../database/models/Question'
import {
    checkExistingUser,
    checkIdField,
    checkQuestionFields,
    checkUserFields,
    checkUsernameField,
    createAccountCheck, verifyToken
} from './middleware'
import {Database} from "../database/Database";


const router: express.Router = express.Router();





router.get('/:admin/users', checkExistingUser, verifyToken, async (req: express.Request, res: express.Response) => {
    try {
        const users = await Database.getAllUsers();
        users.forEach((user)=>{
            delete user.dataValues.password;
            delete user.dataValues.createdAt;
            delete user.dataValues.updatedAt;
        })
        res.status(StatusCodes.OK).json({users});
    } catch (error) {
        res.status(StatusCodes.BAD_REQUEST).json({ message: `An error occured: ${error}` });
    }
});

router.get('/:admin/questions',  checkExistingUser, verifyToken, async (req: express.Request, res: express.Response) => {
    try {
        const questions = await Database.getAllQuestions();
        questions.forEach(q => {
            q.possibleResponse = JSON.parse(q.possibleResponse);
            q.correctResponse=parseInt(String(q.correctResponse));
            delete q.dataValues.createdAt;
            delete q.dataValues.updatedAt;
        });

        res.status(StatusCodes.OK).json({ questions: questions });

    } catch (error) {
        res.status(StatusCodes.BAD_REQUEST).json({ error: `An error occured: ${error}` });
    }
});

router.post('/:admin/users', checkExistingUser, checkUserFields, verifyToken, (req: express.Request, res: express.Response) => {
    createAccountCheck(req, res);
});

router.post('/:admin/questions', checkExistingUser, checkQuestionFields, verifyToken, async (req: express.Request, res: express.Response) => {
    const data = req.body;
    const correctResponse: string = data.possibleResponse[data.correctResponse];
    if (correctResponse !== undefined) {
        try{
            const result=await Database.createQuestion(data.question, data.possibleResponse, data.correctResponse, data.category);
            if (result !== -1) {
                res.status(StatusCodes.OK).json({
                    new_question: {
                        id: result,
                        question: data.question,
                        possibleResponse: data.possibleResponse,
                        correctResponse: correctResponse,
                        category: data.category
                    }
                });
            }
        }catch(error){
            res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});

        }
    } else {
        res.status(StatusCodes.NOT_ACCEPTABLE).json({error: "Correct Response index must not reach the maximum capacity of the array possibleResponse"});
    }
});

router.put('/:admin/users/:username', checkExistingUser, checkUsernameField, verifyToken, async (req: express.Request, res: express.Response) => {
    const data=req.body;
    const username = req.params.username;
    try{
        const user = await User.findOne({where: {username}});
        if(user){
            if(req.params.admin === username && data.accountType!==undefined){
                res.status(StatusCodes.NOT_ACCEPTABLE).send(`Edit your account type is not possible`);
                return;
            }
            try{
                const nbUserUpdated=await Database.updateUserAccount(data.username, data.password, data.firstname, data.lastname, data.email, data.accountType);
                if(nbUserUpdated){
                    res.status(StatusCodes.OK).json({
                        message: `User ${username} updated`
                    });
                }
            }catch(error){
                res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
            }
        }else{
            res.status(StatusCodes.NOT_FOUND).send(`The user ${username} not exist`);
        }
    }catch (error){
        res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
    }



});

router.put('/:admin/questions/:question_id', checkExistingUser,checkIdField, verifyToken, async (req: express.Request, res: express.Response) => {
    const data=req.body;
    const id = req.params.question_id;
    try{
        const question = await Question.findOne({where: {id}});
        if(question){
            try{
                const nbQuestionUpdated=await Database.updateQuestion(data.id, data.question, data.possibleResponse, data.correctResponse, data.category);
                if(nbQuestionUpdated){
                    res.status(StatusCodes.OK).json({
                        message: `Question ${data.id} updated`
                    });
                }
            }catch(error){
                res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
            }
        }else{
            res.status(StatusCodes.NOT_FOUND).send(`The question ${data.id} not exist`);
        }
    }catch (error){
        res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
    }
});



router.delete('/:admin/users/:username', checkExistingUser, verifyToken, async (req: express.Request, res: express.Response) => {
    let username=req.params.username;
    if(req.params.admin !== username) {
        try{
            let userDelete=await Database.deleteUser(username);
            console.log(`user delete= ${userDelete}`)
            if(userDelete === 1){
                res.status(StatusCodes.OK).json({message: `The user ${username} is successfully deleted`});
            }else{
                res.status(StatusCodes.NOT_FOUND).send(`User "${username}" not exist`);
            }

        }catch(error){
            res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
        }

    }else{
        res.status(StatusCodes.NOT_ACCEPTABLE).send(`Delete your account is not possible`);
    }

});

router.delete('/:admin/questions/:question_id', checkExistingUser, verifyToken, async (req: express.Request, res: express.Response) => {
    let questionId=parseInt(req.params.question_id);
    try {
        let questionDelete = await Database.deleteQuestion(questionId);
        console.log(`question delete= ${questionDelete}`)
        if (questionDelete === 1) {
            res.status(StatusCodes.OK).json({message: `The question ${questionId} is successfully deleted`});
        } else {
            res.status(StatusCodes.NOT_FOUND).send(`Question "${questionId}" not exist`);
        }

    } catch (error) {
        res.status(StatusCodes.BAD_REQUEST).json({error: `An error occured: ${error}`});
    }



});

router.get('/:admin', checkExistingUser, verifyToken, async (req: express.Request, res: express.Response) => {
    const username = req.params.admin
    let user=await Database.infoUser(username);
    delete user.dataValues.password;
    delete user.dataValues.createdAt;
    delete user.dataValues.updatedAt;
    if(user){
        res.status(StatusCodes.OK).json({info_user: user.dataValues});
    }else{
        res.status(StatusCodes.NOT_FOUND).json({message: "USER_NOT_FOUND"});
    }



});
export default router;