[[:oktatas:web:back-end_framework:express|< Express]]

====== Express - Azonosítás ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2023
  * Szerkesztve: 2024
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== Bevezetés =====

Az útvonalak védelmét úgy tudjuk ellátni, ha van felhasználó aki be tud jelentkezni, és sikeres bejelentkezés után kap egy tokent, amivel majd elérheti a védett útvonalakat. 

Az útválasztóban beállítható, hogy adott útvonalak csak akkor érhetők el, ha visszakapjuk az érvényes tokent. Ehhez egy köztes szoftvert fogunk használni a tokenek ellenőrzésére. A tokeneket sikeres bejelentkezéskor készítjük.

A példánkban a jsonwebtoken-t fogjuk használni. A token szerveroldalon keletkezik, de kliens oldalon tároljuk.

===== Felhasználó felvétele =====
==== User modell ====

A felhasználók kezeléséhez egy User nevű modellben leírjuk a felhasználóról mit tárolunk.

<code javascript app/models/user.js>
const { DataTypes } = require('sequelize')
const sequelize = require('../database/mariadb')
 
const User = sequelize.define('User', {
    id: { 
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
    },
    name: { type: DataTypes.STRING,  allowNull: false  },
    email: { type: DataTypes.STRING,  allowNull: true  },
    password: { type: DataTypes.STRING , allowNull: false }
})
 
//A model és az adatbázis szinkronizálása, nem erőltetve.
sequelize.sync({
    force: false
})
module.exports = User

</code>

==== AuthController ====

Az Auth kontroller helyett készíthetnék akár egy User kontrollert is, de az Auth névhez jobban illek majd a login() metódus.

Készítsük el az app/controllers/authcontroller.js fájlt:

<code javascript app/controllers/authcontroller.js>
const bcrypt = require('bcryptjs')

const User = require('../models/user')

const AuthController = {
    async register(req, res) {
    
        //Ellenőrizzük megérkeznek-e a kívánt mezők:
        if(!req.body.name ||
            !req.body.email ||
            !req.body.password ||
            !req.body.password_confirmation) {
            res.status(400)
            res.json({
                success: false,
                message: 'Hiba! A bejövő adatok hibásak!'
            })
        }

        if(req.body.password != req.body.password_confirmation) {
            res.status(400).send({
                success: false,
                message: "A jelszavak nem egyeznek!"
            })
        }        

        try {
            User.findOne({
                where: {
                    name: req.body.name
                }
            })
            .then(user => {
                if(user) {
                    res.status(400)
                    res.json({ 
                        message: "A felhasználó már létezik: " + user.name
                    })
                }else {
                    const user = {
                        name: req.body.name,
                        email: req.body.email,
                        password: bcrypt.hashSync(req.body.password)
                    }
                    User.create(user)
                    .then( result => {
                        res.status(201)
                        res.json({
                            succes: true,
                            data: result
                        })
                    })
         
                }
            })
        } catch (error) {
            res.status(500)
            res.json({
                success: true,
                message: 'Hiba! A felhasználó létrehozása sikertelen'
            })
        }        
    }
}

module.exports = AuthController
</code>

==== Routing ====

Írjunk egy új útválasztó sort:
<code javascript>
const AuthController = require('../controllers/authcontroller')
//...
router.post('/register', AuthController.register)
</code>


A teljes kód:

<code javascript app/routes/api.js>
const Router = require('express');
const router = Router();

const EmployeeController = require('../controllers/employeecontroller')
const AuthController = require('../controllers/authcontroller')

router.get('/employees', EmployeeController.index)
router.post('/employees', EmployeeController.store)
router.put('/employees/:id', EmployeeController.update)
router.delete('/employees/:id', EmployeeController.destroy)

router.post('/register', AuthController.register)

module.exports = router

</code>

===== Bejelentkezés =====

==== APP_KEY ====

Vegyük fel a .env fájlban az APP_KEY tulajdonságot:

<code bash>
APP_KEY=3434384383343
</code>

Írjunk bele, legalább 32 számot és betűt.
==== Az authcontroller.js-ben ====

<code javascript app/controllers/authcontroller.js>
const jwt = require('jsonwebtoken')

//...

    async login(req, res) {
        if(!req.body.name || !req.body.password) {
            res.status(400).send({
                message: "Hiba! A felhasználónév vagy jelszó hibás!"
            })
            return
        }
        const user = {
            name: req.body.name,
            password: bcrypt.hashSync(req.body.password)
        }
        User.findOne({
            where: {
                name: req.body.name
            }
        })
        .then(user => {
            if(!user) {
                return res.status(404).send({ message: "User not found."})
            }
            var passwordIsValid = bcrypt.compareSync(
                req.body.password,
                user.password
            );
            if(!passwordIsValid) {
                res.status(401).send({
                    accessToken: null,
                    message: "Invalid password!"
                });
            }
            var token = jwt.sign({ id: user.id }, process.env.APP_KEY, {
                expiresIn: 86400 //24 óra
            });
            res.status(200).send({
                id: user.id,
                name: user.name,
                email: user.email,
                accessToken: token
            });
        })        
    }
</code>

==== Útválasztás ====

<code javascript>
router.post('/login', AuthController.login)
</code>


===== Útvonal védelme =====

==== Token ellenőrző köztes szoftver ====

<code javascript app/middleware/authjwt.js>
const jwt = require("jsonwebtoken");
require('dotenv').config()
 
exports.verifyToken = (req, res, next) => {
    let authData = req.headers.authorization;
    if(!authData) {
        return res.status(403).send({
            message: 'No token provided!'
        })
    }
    let token = authData.split(' ')[1];
 
    jwt.verify(token, process.env.APP_KEY, (err, decoded) => {
        if(err) {
            return res.status(401).send({
                message: "Unauthorized!"
            })
        }
        req.userId = decoded.id;
        next()
    })
};
</code>


==== Útválasztás ====

<code javascript>
const { verifyToken } = require('../middleware/authjwt');
//...
router.post('/employees', [verifyToken], EmployeeController.store)

</code>


Ellenőrzés, például:

<code>
http post localhost:8000/api/employees 
name='Verdi Ernő' city='Szeged' 
-A bearer -a eyJhbG
</code>

A -a után a token írjuk, ami valójában jóval hosszabb.


Állítsuk be az update és delete műveletre is:

<code javascript>
router.delete('/employees/:id', [verifyToken], employees.destroy);
router.put('/employees/:id', [verifyToken], employees.update);
</code>