Metode CRUD utilizatori

Model utilizator + Bcrypt + JWT

În cadrul folderului routes, creăm fișierul user.routes.js care va conține toate metodele CRUD pentru utilizatori.

Începem prin adăugarea importurilor necesare și prin instanțierea router-ului, si ulterior prin adăugarea rutelor:

const { User } = require('../database/models');
const express = require('express');
const bcrypt = require('bcrypt');
const {verifyToken} = require('../utils/token.js');

const router = express.Router();

1. Creare utilizator

router.post('/', async (req, res) => {
    try {
        const existingUser = await User.findOne({
            where: {
                email: req.body.email
            }
        })

        if(existingUser) {
            return res.status(400).json({success: false, message: 'User already exists', data: {}});
        }

        const salt = bcrypt.genSaltSync(10);
        const hashedPassword = bcrypt.hashSync(req.body.password, salt);

        const user = await User.create({
            ...req.body,
            password: hashedPassword,
        })

        delete user.dataValues.password;

        res.status(201).json({success: true, message: 'User created successfully', data: user});
    } catch (error) {
        res.status(500).json({success: false, message: 'Error creating user', data: error.message});
    }
})

Descrierea rutei de creare a unui utilizator:

• Scop: Creează un nou utilizator în baza de date.

• Endpoint: POST /

• Partea de securitate: Nu folosește verifyToken, deci este publică (oricine poate crea un cont).

• Verificări efectuate:

  • Verifică dacă există deja un utilizator cu același email.

  • Dacă există, returnează 400 Bad Request cu mesajul User already exists.

• Procesul de creare:

  • Generează un salt cu bcrypt și criptează parola (password) trimisă în request.

  • Creează un obiect User în baza de date cu datele din request, înlocuind parola cu versiunea criptată.

• Răspuns:

  • Elimină parola din obiectul creat (delete user.dataValues.password).

  • Returnează 201 Created și datele utilizatorului creat, fără parolă.

• Tratament erori:

  • Dacă apare o eroare în procesul de creare, returnează 500 Internal Server Error cu mesajul erorii.

2. Actualizare utilizator

router.put('/:id', verifyToken, async (req, res) => {
    try {
        const id = req.params.id;

        if (isNaN(id)) {
            return res.status(400).json({success: false, message: 'User id is not valid', data: {}})
        }

        const user = await User.findByPk(id);

        if (!user) {
            return res.status(404).json({success: false, message: 'User not found', data: {}})
        }

        const updatedUser = await user.update({
            ...req.body
        })

        delete updatedUser.dataValues.password;

        res.status(200).json({success: true, message: 'User updated successfully', data: updatedUser});
    } catch (error) {
        res.status(500).json({success: false, message: 'Error updating user', data: error.message});
    }
})

Descrierea rutei de actualizare a unui utilizator:

• Scop: Actualizează datele unui utilizator existent.

• Endpoint: PUT /:id (unde :id este ID-ul utilizatorului).

• Securitate: Folosește verifyToken, deci doar utilizatorii autentificați pot face modificări.

• Verificări efectuate:

  • Verifică dacă id este un număr valid; dacă nu, returnează 400 Bad Request.

  • Verifică dacă utilizatorul există în baza de date; dacă nu, returnează 404 Not Found.

• Procesul de actualizare:

  • Actualizează câmpurile din request (req.body) pentru utilizatorul găsit.

  • Elimină parola din obiectul returnat (delete updatedUser.dataValues.password) pentru securitate.

• Răspuns:

  • Returnează 200 OK și datele utilizatorului actualizat, fără parolă.

• Tratament erori:

  • Dacă apare o eroare în procesul de update, returnează 500 Internal Server Error cu mesajul erorii.

3. Ștergere utilizator

router.delete('/:id', verifyToken, async (req, res) => {
    try {
        const id = req.params.id;

        if (isNaN(id)) {
            return res.status(400).json({success: false, message: 'User id is not valid', data: {}})
        }

        const user = await User.findByPk(id);

        if (!user) {
            return res.status(404).json({success: false, message: 'User not found', data: {}})
        }

        await user.destroy();

        res.status(200).json({success: true, message: 'User successfully deleted', data: {}});
    } catch (error) {
        res.status(500).json({success: false, message: 'Error deleting user', data: error.message});
    }
})

module.exports = router;

Descrierea rutei de ștergere a unui utilizator:

• Scop: Șterge un utilizator existent din baza de date.

• Endpoint: DELETE /:id (unde :id este ID-ul utilizatorului).

• Securitate: Folosește verifyToken, deci doar utilizatorii autentificați pot șterge conturi.

• Verificări efectuate:

  • Verifică dacă id este un număr valid; dacă nu, returnează 400 Bad Request.

  • Verifică dacă utilizatorul există în baza de date; dacă nu, returnează 404 Not Found.

• Procesul de ștergere:

  • Șterge utilizatorul găsit folosind metoda destroy().

• Răspuns:

  • Returnează 200 OK cu mesajul User successfully deleted.

• Tratament erori:

  • Dacă apare o eroare în procesul de ștergere, returnează 500 Internal Server Error cu mesajul erorii.

4. Preluare utilizatori/utilizator pe bază de ID

router.get('/', verifyToken, async (req, res) => {
    try {
        const users = await User.findAll({
            attributes: {
                exclude: ['password']
            }
        });

        res.status(200).json({success: true, message: 'Users retrieved successfully', data: users});
    } catch (error) {
        res.status(500).json({success: false, message: 'Error retrieving users', data: error.message});
    }
})

router.get('/:id', verifyToken, async (req, res) => {
    try {
        const id = req.params.id;

        if (isNaN(id)) {
            return res.status(400).json({success: false, message: 'User id is not valid', data: {}})
        }

        const user = await User.findByPk(id, {
            attributes: {
                exclude: ['password']
            }
        });

        if (!user) {
            return res.status(404).json({success: false, message: 'User not found', data: {}})
        }

        res.status(200).json({success: true, message: 'User was found', data: user})
    } catch (error) {
        res.status(500).json({success: false, message: 'Error retrieving user', data: error.message});
    }
})

Descrierea rutelor de preluare a utilizatorilor:

GET /

• Scop: Returnează toți utilizatorii din baza de date.

• Endpoint: GET /

• Securitate: Folosește verifyToken → doar utilizatorii autentificați pot accesa lista.

• Proces:

  • Preia toți utilizatorii din baza de date (User.findAll()).

  • Exclude câmpul password din răspuns pentru securitate.

• Răspuns:

  • 200 OK cu lista de utilizatori dacă totul merge bine.

  • 500 Internal Server Error dacă apare o eroare.

---

GET /:id

• Scop: Returnează un singur utilizator după ID.

• Endpoint: GET /:id (unde :id este ID-ul utilizatorului)

• Securitate: Folosește verifyToken → doar utilizatorii autentificați pot accesa datele.

• Verificări:

  • Verifică dacă id este un număr valid; altfel returnează 400 Bad Request.

  • Verifică dacă utilizatorul există; dacă nu, returnează 404 Not Found.

• Proces:

  • Preia utilizatorul din baza de date (User.findByPk()), fără parola.

• Răspuns:

  • 200 OK cu datele utilizatorului.

  • 500 Internal Server Error dacă apare o eroare.

5. Implementare metode CRUD utilizatori la nivel de server

Ca metodele CRUD pentru utilizatori să poată fi folosite, este nevoie să ne asigurăm că serverul are la cunoștință existența acestora.

Așadar, mergem în fisierul index.js din folderul server, unde adăugăm importul router-ului de user și middlware-ul de rutare către metodele CRUD pentru utilizatori.

const express = require('express');
const cors = require('cors');
const dotenv = require('dotenv');
const morgan = require('morgan');
const app = express();
dotenv.config();

const authRoutes = require('./routes/auth.routes');
const userRoutes = require('./routes/user.routes');

const PORT = process.env.PORT || 3000;

app.use(morgan('dev'))
app.use(cors());
app.use(express.json());

app.get('/', (req, res) => {
    res.status(200).json({ message: 'Hello' })
})
app.use('/auth', authRoutes);
app.use('/users', userRoutes);

app.listen(PORT, () => {
    console.log(`Server successfully started on port ${PORT}`)
})

Middleware-ul de rutare (route middleware):

• Atașează router-ul userRoutes la ruta de bază /user.

Practic, toate rutele definite în userRoutes vor fi accesibile cu prefixul /users.

Ruta în userRoutes	Ruta finală în aplicație
router.get('/', ...)	/users/
router.get('/:id', ...)	/users/:id
router.post('/', ...)	/users/
router.put('/:id', ...)	/users/:id
router.delete('/:id', ...)	/users/:id