magdo
659 lines
17 KiB
Markdown
659 lines
17 KiB
Markdown
# Backend Fejlesztés Gyakorló Feladat
|
|
## Authentication & Authorization Implementáció
|
|
|
|
---
|
|
|
|
## 📋 Tartalom
|
|
|
|
1. [Projekt Áttekintés](#projekt-áttekintés)
|
|
2. [Architektúra](#architektúra)
|
|
3. [Előkészületek](#előkészületek)
|
|
4. [A Feladat](#a-feladat)
|
|
5. [Implementációs Útmutató](#implementációs-útmutató)
|
|
6. [Tesztelés](#tesztelés)
|
|
7. [Hasznos Források](#hasznos-források)
|
|
|
|
---
|
|
|
|
## 🎯 Projekt Áttekintés
|
|
|
|
Ez egy gyakorló projekt backend fejlesztők számára, amely az **Authentication** és **Authorization** implementálására fókuszál. A projekt egy blog platformot szimulál, ahol a felhasználók regisztrálhatnak, bejelentkezhetnek, és blogokat írhatnak.
|
|
|
|
### Technológiai Stack
|
|
|
|
- **Node.js** + **Express.js** - Backend framework
|
|
- **Prisma ORM** - Database ORM
|
|
- **PostgreSQL** - Relációs adatbázis
|
|
- **Redis** - Cache és session management
|
|
- **JWT** - Token-based authentication
|
|
- **bcrypt** - Jelszó hash-elés
|
|
- **Cookie-parser** - Cookie kezelés
|
|
- **Docker** - Konténerizáció
|
|
|
|
### Amit MEG KELL implementálni (FELADAT):
|
|
|
|
✅ Authentication (Hitelesítés)
|
|
- Regisztráció
|
|
- Bejelentkezés
|
|
- Kijelentkezés
|
|
- Token refresh
|
|
- Current user lekérés
|
|
|
|
✅ Authorization (Jogosultság kezelés)
|
|
- Authentication middleware
|
|
- Role-based access control (RBAC)
|
|
- Resource ownership ellenőrzés
|
|
|
|
### Amit NEM kell implementálni (már kész):
|
|
|
|
✅ Prisma schema és migrációk
|
|
✅ Repository pattern implementáció
|
|
✅ CQRS command/query handlers
|
|
✅ Blog CRUD műveletek
|
|
✅ Docker konfiguráció
|
|
✅ Projekt struktúra
|
|
|
|
---
|
|
|
|
## 🏗️ Architektúra
|
|
|
|
A projekt **Clean Architecture** és **CQRS** mintákat követ:
|
|
|
|
```
|
|
src/
|
|
├── domain/ # Domain réteg (business logic)
|
|
│ ├── models/ # Domain modellek
|
|
│ │ ├── User.js
|
|
│ │ └── Blog.js
|
|
│ └── repositories/ # Repository interfészek
|
|
│ ├── IUserRepository.js
|
|
│ └── IBlogRepository.js
|
|
│
|
|
├── application/ # Application réteg (use cases)
|
|
│ ├── commands/ # Command objektumok
|
|
│ │ ├── CreateBlogCommand.js
|
|
│ │ ├── UpdateBlogCommand.js
|
|
│ │ └── DeleteBlogCommand.js
|
|
│ ├── queries/ # Query objektumok
|
|
│ │ └── BlogQueries.js
|
|
│ └── handlers/ # Command/Query handlerek
|
|
│ ├── CreateBlogHandler.js
|
|
│ ├── UpdateBlogHandler.js
|
|
│ ├── DeleteBlogHandler.js
|
|
│ └── BlogQueryHandler.js
|
|
│
|
|
├── infrastructure/ # Infrastructure réteg (külső függőségek)
|
|
│ ├── database/ # Database kapcsolatok
|
|
│ │ ├── prisma.js
|
|
│ │ └── redis.js
|
|
│ ├── repositories/ # Repository implementációk
|
|
│ │ ├── UserRepository.js
|
|
│ │ └── BlogRepository.js
|
|
│ └── config/ # Konfigurációk
|
|
│ └── index.js
|
|
│
|
|
├── api/ # API réteg (HTTP)
|
|
│ ├── controllers/ # Controller-ek
|
|
│ │ ├── AuthController.js # ⚠️ IMPLEMENTÁLANDÓ
|
|
│ │ └── BlogController.js
|
|
│ ├── routes/ # Route definíciók
|
|
│ │ ├── authRoutes.js
|
|
│ │ ├── blogRoutes.js
|
|
│ │ └── userRoutes.js
|
|
│ └── middlewares/ # Middleware-ek
|
|
│ ├── authMiddleware.js # ⚠️ IMPLEMENTÁLANDÓ
|
|
│ └── errorHandler.js
|
|
│
|
|
└── index.js # Alkalmazás belépési pont
|
|
```
|
|
|
|
### Rétegek Felelősségei
|
|
|
|
**Domain réteg:**
|
|
- Domain modellek és üzleti logika
|
|
- Repository interfészek (dependency inversion)
|
|
|
|
**Application réteg:**
|
|
- Use case-ek implementációja
|
|
- Command/Query objektumok és handlerek
|
|
- Validációs logika
|
|
|
|
**Infrastructure réteg:**
|
|
- Külső rendszerek integrációja (DB, Redis)
|
|
- Repository implementációk
|
|
- Konfigurációk
|
|
|
|
**API réteg:**
|
|
- HTTP kérések kezelése
|
|
- Routing
|
|
- Middleware-ek
|
|
- Authentication & Authorization ⚠️
|
|
|
|
---
|
|
|
|
## 🚀 Előkészületek
|
|
|
|
### 1. Függőségek telepítése
|
|
|
|
```bash
|
|
npm install
|
|
```
|
|
|
|
### 2. Környezeti változók beállítása
|
|
|
|
Másold le a `.env.example` fájlt `.env` néven:
|
|
|
|
```bash
|
|
cp .env.example .env
|
|
```
|
|
|
|
Állítsd be a környezeti változókat `.env` fájlban:
|
|
|
|
```env
|
|
DATABASE_URL="postgresql://postgres:postgres@localhost:5432/blog_db?schema=public"
|
|
REDIS_HOST=localhost
|
|
REDIS_PORT=6379
|
|
|
|
JWT_SECRET=valami-nagyon-titkos-kulcs-ide
|
|
JWT_EXPIRES_IN=7d
|
|
JWT_REFRESH_SECRET=masik-nagyon-titkos-kulcs-ide
|
|
JWT_REFRESH_EXPIRES_IN=30d
|
|
|
|
PORT=3000
|
|
NODE_ENV=development
|
|
|
|
COOKIE_SECRET=cookie-titkos-kulcs-ide
|
|
```
|
|
|
|
⚠️ **FONTOS:** Production környezetben használj erős, random generált kulcsokat!
|
|
|
|
### 3. Docker konténerek indítása
|
|
|
|
```bash
|
|
npm run docker:up
|
|
```
|
|
|
|
Ez elindítja a PostgreSQL és Redis konténereket.
|
|
|
|
### 4. Adatbázis migráció
|
|
|
|
```bash
|
|
npm run prisma:migrate
|
|
npm run prisma:generate
|
|
```
|
|
|
|
### 5. Projekt indítása (development)
|
|
|
|
```bash
|
|
npm run dev
|
|
```
|
|
|
|
A szerver elindul a `http://localhost:3000` címen.
|
|
|
|
Ellenőrizd a health endpoint-ot:
|
|
```bash
|
|
curl http://localhost:3000/health
|
|
```
|
|
|
|
---
|
|
|
|
## 📝 A Feladat
|
|
|
|
A feladatod **három fő komponens** implementálása:
|
|
|
|
### 1️⃣ AuthController implementálása
|
|
|
|
**Fájl:** `src/api/controllers/AuthController.js`
|
|
|
|
Implementálandó metódusok:
|
|
|
|
#### `register(req, res)`
|
|
- Új felhasználó regisztrációja
|
|
- Input validáció (email, username, password)
|
|
- Uniqueness ellenőrzés (email és username)
|
|
- Jelszó hash-elés `bcrypt`-tel
|
|
- User létrehozása repository-n keresztül
|
|
- JWT token generálás
|
|
- HTTP-only cookie beállítás
|
|
- User publikus adatainak visszaadása (jelszó nélkül!)
|
|
|
|
#### `login(req, res)`
|
|
- Bejelentkezés email vagy username alapján
|
|
- User keresése repository-val
|
|
- Jelszó ellenőrzés `bcrypt.compare()`-val
|
|
- Access és refresh token generálás
|
|
- Cookie-k beállítása (httpOnly, secure, sameSite)
|
|
- Opcionális: Session tárolás Redis-ben
|
|
- Sikeres bejelentkezés esetén user adatok és tokenek visszaadása
|
|
|
|
#### `logout(req, res)`
|
|
- Cookie-k törlése
|
|
- Redis session törlése (ha van)
|
|
- Refresh token invalidálás
|
|
|
|
#### `refreshToken(req, res)`
|
|
- Refresh token kiolvasása cookie-ból
|
|
- Token validálás
|
|
- Új access token generálás
|
|
- Új cookie beállítás
|
|
|
|
#### `getCurrentUser(req, res)`
|
|
- Bejelentkezett user adatainak visszaadása
|
|
- `req.user` alapján (amit az auth middleware állít be)
|
|
|
|
---
|
|
|
|
### 2️⃣ AuthMiddleware-ek implementálása
|
|
|
|
**Fájl:** `src/api/middlewares/authMiddleware.js`
|
|
|
|
#### `authenticateToken(req, res, next)`
|
|
|
|
Ez a middleware **minden védett route előtt** fut.
|
|
|
|
**Feladatai:**
|
|
1. JWT token kiolvasása:
|
|
- Cookie-ból: `req.cookies.accessToken`
|
|
- VAGY Authorization header-ből: `Bearer <token>`
|
|
2. Token validálás `jwt.verify()`-val
|
|
3. User ID kinyerése a token payload-ból
|
|
4. User betöltése repository-val
|
|
5. `req.user` beállítása a user objektummal
|
|
6. `next()` hívása
|
|
|
|
**Hibakezelés:**
|
|
- Ha nincs token → 401 Unauthorized
|
|
- Ha érvénytelen token → 401 Unauthorized
|
|
- Ha user nem létezik → 401 Unauthorized
|
|
|
|
#### `requireRole(allowedRoles)`
|
|
|
|
Ez egy **higher-order middleware**, ami role-based access control-t implementál.
|
|
|
|
**Feladatai:**
|
|
1. Visszaad egy middleware függvényt
|
|
2. Ellenőrzi, hogy `req.user` létezik (az `authenticateToken` után fut!)
|
|
3. Ellenőrzi, hogy `req.user.role` benne van-e az `allowedRoles` tömbben
|
|
4. Ha nincs jogosultság → 403 Forbidden
|
|
5. Ha van jogosultság → `next()`
|
|
|
|
**Példa használat:**
|
|
```javascript
|
|
router.delete('/admin/users/:id',
|
|
authenticateToken,
|
|
requireRole(['ADMIN']),
|
|
deleteUserController
|
|
);
|
|
```
|
|
|
|
#### `checkOwnership(getResourceOwnerId)`
|
|
|
|
Ez a middleware **resource ownership** ellenőrzést implementál.
|
|
|
|
**Feladatai:**
|
|
1. Visszaad egy middleware függvényt
|
|
2. Meghívja a `getResourceOwnerId` függvényt, hogy megszerezze a resource tulajdonos ID-ját
|
|
3. Ellenőrzi, hogy:
|
|
- `req.user.id === ownerId` (a user a tulajdonos)
|
|
- VAGY `req.user.role === 'ADMIN'` (ADMIN mindent módosíthat)
|
|
4. Ha egyik sem teljesül → 403 Forbidden
|
|
5. Ha OK → `next()`
|
|
|
|
**Példa használat:**
|
|
```javascript
|
|
router.put('/blogs/:id',
|
|
authenticateToken,
|
|
checkOwnership(async (req) => {
|
|
const blog = await blogRepository.findById(req.params.id);
|
|
return blog.authorId;
|
|
}),
|
|
(req, res) => blogController.updateBlog(req, res)
|
|
);
|
|
```
|
|
|
|
---
|
|
|
|
### 3️⃣ Middleware-ek integrálása a route-okba
|
|
|
|
**Fájlok:**
|
|
- `src/api/routes/authRoutes.js`
|
|
- `src/api/routes/blogRoutes.js`
|
|
|
|
Add hozzá az `authenticateToken` middleware-t a védett endpoint-okhoz:
|
|
|
|
**authRoutes.js:**
|
|
```javascript
|
|
router.post('/logout', authenticateToken, (req, res) => authController.logout(req, res));
|
|
router.get('/me', authenticateToken, (req, res) => authController.getCurrentUser(req, res));
|
|
```
|
|
|
|
**blogRoutes.js:**
|
|
```javascript
|
|
router.post('/', authenticateToken, (req, res) => blogController.createBlog(req, res));
|
|
router.put('/:id', authenticateToken, checkOwnership(...), (req, res) => blogController.updateBlog(req, res));
|
|
router.delete('/:id', authenticateToken, checkOwnership(...), (req, res) => blogController.deleteBlog(req, res));
|
|
```
|
|
|
|
---
|
|
|
|
## 🛠️ Implementációs Útmutató
|
|
|
|
### JWT Token Generálás
|
|
|
|
```javascript
|
|
import jwt from 'jsonwebtoken';
|
|
|
|
// Access token generálás
|
|
const accessToken = jwt.sign(
|
|
{
|
|
userId: user.id,
|
|
email: user.email,
|
|
role: user.role
|
|
},
|
|
process.env.JWT_SECRET,
|
|
{ expiresIn: process.env.JWT_EXPIRES_IN }
|
|
);
|
|
|
|
// Refresh token generálás
|
|
const refreshToken = jwt.sign(
|
|
{ userId: user.id },
|
|
process.env.JWT_REFRESH_SECRET,
|
|
{ expiresIn: process.env.JWT_REFRESH_EXPIRES_IN }
|
|
);
|
|
```
|
|
|
|
### JWT Token Validálás
|
|
|
|
```javascript
|
|
import jwt from 'jsonwebtoken';
|
|
|
|
try {
|
|
const decoded = jwt.verify(token, process.env.JWT_SECRET);
|
|
// decoded.userId, decoded.email, decoded.role
|
|
} catch (error) {
|
|
// Token érvénytelen vagy lejárt
|
|
throw new Error('Invalid token');
|
|
}
|
|
```
|
|
|
|
### Jelszó Hash-elés
|
|
|
|
```javascript
|
|
import bcrypt from 'bcrypt';
|
|
|
|
// Hash-elés (regisztrációnál)
|
|
const saltRounds = 10;
|
|
const hashedPassword = await bcrypt.hash(password, saltRounds);
|
|
|
|
// Ellenőrzés (bejelentkezésnél)
|
|
const isValid = await bcrypt.compare(password, user.password);
|
|
```
|
|
|
|
### Cookie Beállítás
|
|
|
|
```javascript
|
|
// Access token cookie
|
|
res.cookie('accessToken', accessToken, {
|
|
httpOnly: true, // JavaScript nem férhet hozzá
|
|
secure: process.env.NODE_ENV === 'production', // Csak HTTPS-en
|
|
sameSite: 'strict', // CSRF védelem
|
|
maxAge: 7 * 24 * 60 * 60 * 1000 // 7 nap
|
|
});
|
|
|
|
// Refresh token cookie
|
|
res.cookie('refreshToken', refreshToken, {
|
|
httpOnly: true,
|
|
secure: process.env.NODE_ENV === 'production',
|
|
sameSite: 'strict',
|
|
maxAge: 30 * 24 * 60 * 60 * 1000 // 30 nap
|
|
});
|
|
```
|
|
|
|
### Cookie Törlés
|
|
|
|
```javascript
|
|
res.clearCookie('accessToken');
|
|
res.clearCookie('refreshToken');
|
|
```
|
|
|
|
### Redis Session Tárolás (Opcionális)
|
|
|
|
```javascript
|
|
import { redis } from '../infrastructure/database/redis.js';
|
|
|
|
// Session mentése
|
|
await redis.set(
|
|
`session:${userId}`,
|
|
JSON.stringify({ userId, email, loginTime: new Date() }),
|
|
'EX',
|
|
60 * 60 * 24 * 7 // 7 nap TTL
|
|
);
|
|
|
|
// Session lekérése
|
|
const session = await redis.get(`session:${userId}`);
|
|
const sessionData = JSON.parse(session);
|
|
|
|
// Session törlése
|
|
await redis.del(`session:${userId}`);
|
|
```
|
|
|
|
### Token Kiolvasás Cookie-ból vagy Header-ből
|
|
|
|
```javascript
|
|
function getTokenFromRequest(req) {
|
|
// Cookie-ból
|
|
if (req.cookies && req.cookies.accessToken) {
|
|
return req.cookies.accessToken;
|
|
}
|
|
|
|
// Authorization header-ből
|
|
const authHeader = req.headers.authorization;
|
|
if (authHeader && authHeader.startsWith('Bearer ')) {
|
|
return authHeader.substring(7);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 🧪 Tesztelés
|
|
|
|
### 1. Regisztráció
|
|
|
|
```bash
|
|
curl -X POST http://localhost:3000/api/auth/register \
|
|
-H "Content-Type: application/json" \
|
|
-d '{
|
|
"email": "test@example.com",
|
|
"username": "testuser",
|
|
"password": "SecurePassword123"
|
|
}'
|
|
```
|
|
|
|
**Elvárt válasz:**
|
|
```json
|
|
{
|
|
"success": true,
|
|
"data": {
|
|
"user": {
|
|
"id": "uuid...",
|
|
"email": "test@example.com",
|
|
"username": "testuser",
|
|
"role": "USER"
|
|
},
|
|
"accessToken": "eyJhbGc...",
|
|
"refreshToken": "eyJhbGc..."
|
|
}
|
|
}
|
|
```
|
|
|
|
### 2. Bejelentkezés
|
|
|
|
```bash
|
|
curl -X POST http://localhost:3000/api/auth/login \
|
|
-H "Content-Type: application/json" \
|
|
-d '{
|
|
"email": "test@example.com",
|
|
"password": "SecurePassword123"
|
|
}'
|
|
```
|
|
|
|
### 3. Current User
|
|
|
|
```bash
|
|
curl -X GET http://localhost:3000/api/auth/me \
|
|
-H "Authorization: Bearer <access_token>"
|
|
```
|
|
|
|
VAGY cookie-val:
|
|
|
|
```bash
|
|
curl -X GET http://localhost:3000/api/auth/me \
|
|
--cookie "accessToken=<token>"
|
|
```
|
|
|
|
### 4. Blog Létrehozás (Védett endpoint)
|
|
|
|
```bash
|
|
curl -X POST http://localhost:3000/api/blogs \
|
|
-H "Content-Type: application/json" \
|
|
-H "Authorization: Bearer <access_token>" \
|
|
-d '{
|
|
"title": "My First Blog",
|
|
"content": "This is awesome!",
|
|
"published": true
|
|
}'
|
|
```
|
|
|
|
### 5. Blog Módosítás (Ownership ellenőrzéssel)
|
|
|
|
```bash
|
|
curl -X PUT http://localhost:3000/api/blogs/<blog_id> \
|
|
-H "Content-Type: application/json" \
|
|
-H "Authorization: Bearer <access_token>" \
|
|
-d '{
|
|
"title": "Updated Title"
|
|
}'
|
|
```
|
|
|
|
### 6. Kijelentkezés
|
|
|
|
```bash
|
|
curl -X POST http://localhost:3000/api/auth/logout \
|
|
-H "Authorization: Bearer <access_token>"
|
|
```
|
|
|
|
---
|
|
|
|
## ✅ Ellenőrző Lista
|
|
|
|
Implementációd akkor teljes, ha:
|
|
|
|
- [ ] ✅ Sikeres regisztráció email + username + password-dal
|
|
- [ ] ✅ Email és username uniqueness ellenőrzés működik
|
|
- [ ] ✅ Jelszó hash-elve van tárolva (bcrypt)
|
|
- [ ] ✅ Sikeres bejelentkezés
|
|
- [ ] ✅ Rossz jelszóval nem lehet bejelentkezni
|
|
- [ ] ✅ JWT token generálódik és cookie-ban tárolódik
|
|
- [ ] ✅ AuthMiddleware validálja a tokent
|
|
- [ ] ✅ Védett endpoint-ok csak token-nal elérhetők
|
|
- [ ] ✅ `/api/auth/me` visszaadja a bejelentkezett user adatait
|
|
- [ ] ✅ Kijelentkezés törli a cookie-kat
|
|
- [ ] ✅ Token refresh működik
|
|
- [ ] ✅ Role-based access control működik (ADMIN vs USER)
|
|
- [ ] ✅ Ownership check működik (csak saját blog módosítható)
|
|
- [ ] ✅ Hibakezelés 401/403 válaszokkal
|
|
|
|
---
|
|
|
|
## 📚 Hasznos Források
|
|
|
|
### Dokumentációk
|
|
|
|
- [JWT](https://jwt.io/) - JSON Web Token
|
|
- [bcrypt](https://www.npmjs.com/package/bcrypt) - Password hashing
|
|
- [Prisma](https://www.prisma.io/docs) - ORM dokumentáció
|
|
- [Express](https://expressjs.com/) - Web framework
|
|
- [cookie-parser](https://www.npmjs.com/package/cookie-parser) - Cookie middleware
|
|
|
|
### Tananyagok
|
|
|
|
- [OWASP Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html)
|
|
- [JWT Best Practices](https://blog.logrocket.com/jwt-authentication-best-practices/)
|
|
- [Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
|
|
- [CQRS Pattern](https://martinfowler.com/bliki/CQRS.html)
|
|
|
|
---
|
|
|
|
## 🐛 Gyakori Hibák és Megoldások
|
|
|
|
### "JWT must be provided"
|
|
- Ellenőrizd, hogy a token szerepel-e a cookie-ban vagy Authorization header-ben
|
|
- Ellenőrizd a cookie nevét (`accessToken`)
|
|
|
|
### "Invalid token"
|
|
- Ellenőrizd a JWT_SECRET változót
|
|
- Lehet, hogy a token lejárt - próbálj újra bejelentkezni
|
|
|
|
### "User already exists"
|
|
- Email vagy username már foglalt
|
|
- Használj egyedi értékeket
|
|
|
|
### "Incorrect password"
|
|
- Ellenőrizd a bcrypt.compare() használatát
|
|
- A paraméterek sorrendje: `bcrypt.compare(plainPassword, hashedPassword)`
|
|
|
|
### "403 Forbidden"
|
|
- Nincs jogosultságod az adott művelethez
|
|
- Ellenőrizd a role-t vagy az ownership-et
|
|
|
|
---
|
|
|
|
## 🎓 Értékelési Szempontok
|
|
|
|
A feladat sikeres megoldása:
|
|
|
|
1. **Működőképesség (40%)**
|
|
- Regisztráció működik
|
|
- Bejelentkezés/kijelentkezés működik
|
|
- Védett endpoint-ok hozzáférés-védelme
|
|
|
|
2. **Biztonság (30%)**
|
|
- Jelszavak hash-elve vannak
|
|
- HTTP-only cookie-k használata
|
|
- JWT token biztonságos kezelése
|
|
- Input validáció
|
|
|
|
3. **Kódminőség (20%)**
|
|
- Letisztult, olvasható kód
|
|
- Megfelelő error handling
|
|
- Architektúra követése
|
|
|
|
4. **Extra funkciók (10%)**
|
|
- Redis session management
|
|
- Token refresh flow
|
|
- Role-based access control
|
|
- Ownership validation
|
|
|
|
---
|
|
|
|
## 💡 Tippek
|
|
|
|
1. **Kezdd a legegyszerűbbel:** Először implementáld a regisztrációt, aztán a logint.
|
|
|
|
2. **Tesztelj folyamatosan:** Minden metódus után tesztelj curl-lel vagy Postman-nel.
|
|
|
|
3. **Nézd meg a meglévő kódot:** A BlogController egy jó példa, hogyan kell használni a repository-kat és handler-eket.
|
|
|
|
4. **Debug logging:** Használj `console.log()`-ot fejlesztés közben, hogy lásd mi történik.
|
|
|
|
5. **Hibakezelés:** Minden async művelet legyen try-catch blokkban.
|
|
|
|
6. **Token lejárat:** Fejlesztés közben használj rövid lejárati időt (pl. 15 perc), hogy tesztelhesd a refresh flow-t.
|
|
|
|
---
|
|
|
|
**Jó munkát és kellemes kódolást! 🚀**
|