Maak interactieve CodeWhisperer-tutorials voor leren en onboarding
description
Maakt het mogelijk om op maat gemaakte, interactieve programmeertutorials te bouwen die het leer- en onboardingproces verbeteren. Deze prompt helpt om de codegeneratie van CodeWhisperer om te zetten in educatieve content, waardoor nieuwe ontwikkelaars complexe taken beter begrijpen en de teamintegratie versneld wordt vergeleken met statische codesnippets of algemene documentatie.
prompt
Help me een interactieve tutorial te maken met Amazon CodeWhisperer die stapsgewijs de volgende programmeertaak behandelt. Omschrijving van de taak: <voer de programmeertaak of het concept in>. Ervaringsniv ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een stapsgewijze interactieve tutorial voor het maken van een REST API-eindpunt voor gebruikersregistratie met e-mailverificatie in Python, gericht op beginners. Ik zal uitleg, voorbeeldcodes en valkuilen toevoegen.
---
## Stap 1: Voorbereiding en omgeving instellen
**Uitleg:**
Voordat je begint, heb je een Python-ontwikkelomgeving nodig. We gaan gebruik maken van Flask, een populair Python-framework voor het maken van REST API's.
**Wat te doen:**
- Installeer Python (bijvoorbeeld via [python.org](https://www.python.org/)).
- Installeer Flask via pip:
```bash
pip install Flask
```
**Valkuil:**
Vergeet niet om een virtuele omgeving te gebruiken om afhankelijkheden overzichtelijk te houden.
---
## Stap 2: Een eenvoudige Flask API opzetten
**Uitleg:**
We starten met het maken van een basis API die een endpoint heeft.
**Voorbeeldcode:**
```python
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
# Hier komt later de registratie-logica
return jsonify({"message": "Registratie ontvangen!", "data": data}), 200
if __name__ == '__main__':
app.run(debug=True)
```
**Wat te doen:**
- Sla dit op als `app.py` en voer uit met:
```bash
python app.py
```
- Test de API met een tool als Postman of curl:
```bash
curl -X POST -H "Content-Type: application/json" -d '{"email": "test@example.com", "password": "123456"}' http://127.0.0.1:5000/register
```
**Valkuil:**
Vergeten `Content-Type: application/json` header mee te sturen, waardoor `request.get_json()` niet werkt.
---
## Stap 3: Gebruikersgegevens opslaan (bijvoorbeeld in geheugen)
**Uitleg:**
Voor de eenvoud bewaren we gebruikers in een lijst. In productie gebruik je een database.
**Voorbeeldcode:**
```python
users = []
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
email = data.get('email')
password = data.get('password')
# Controleer of e-mail al bestaat
if any(user['email'] == email for user in users):
return jsonify({"error": "Email bestaat al."}), 400
# Voeg gebruiker toe
users.append({'email': email, 'password': password, 'verified': False})
# Hier komt e-mail verificatie logica
return jsonify({"message": "Gebruiker geregistreerd, verificatie e-mail verzonden."}), 201
```
**Valkuil:**
Geen controle op ontbrekende velden, wat kan leiden tot fouten.
---
## Stap 4: E-mail verificatie simuleren
**Uitleg:**
Omdat we geen echte e-mails versturen, simuleren we dit door een verificatietoken te genereren en te tonen.
**Voorbeeldcode:**
```python
import uuid
verification_tokens = {}
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
email = data.get('email')
password = data.get('password')
if not email or not password:
return jsonify({"error": "E-mail en wachtwoord zijn verplicht."}), 400
if any(user['email'] == email for user in users):
return jsonify({"error": "Email bestaat al."}), 400
token = str(uuid.uuid4())
verification_tokens[token] = email
users.append({'email': email, 'password': password, 'verified': False})
# Simuleer e-mail door token weer te geven
return jsonify({
"message": "Registratie succesvol! Verifieer je e-mail.",
"verificatielink": f"http://localhost:5000/verify/{token}"
}), 201
@app.route('/verify/<token>', methods=['GET'])
def verify_email(token):
email = verification_tokens.get(token)
if not email:
return jsonify({"error": "Ongeldig verificatietoken."}), 400
# Vind gebruiker en markeer als geverifieerd
for user in users:
if user['email'] == email:
user['verified'] = True
del verification_tokens[token]
return jsonify({"message": "E-mail succesvol geverifieerd."}), 200
return jsonify({"error": "Gebruiker niet gevonden."}), 404
```
**Valkuil:**
Vergeten de token te verwijderen na verificatie, waardoor het hergebruikt kan worden.
---
## Stap 5: Testen en valkuilen vermijden
- Test registratie en verificatie via curl of Postman.
- Controleer of e-mails niet al bestaan.
- Test met ontbrekende gegevens.
- Let op dat wachtwoorden in echte systemen altijd gehasht moeten worden (gebruik bijvoorbeeld `bcrypt`).
---
## Samenvatting
Door deze stappen te volgen, heb je een eenvoudige REST API gemaakt voor gebruikersregistratie met e-mailverificatie. In een echte toepassing zou je:
- Een database gebruiken (bijv. SQLite, PostgreSQL).
- E-mails versturen via bijvoorbeeld SMTP of een service zoals SES.
- Wachtwoorden hashen voor veiligheid.
- Beveiligingsmaatregelen toepassen.
---
Wil je dat ik je help met het genereren van een volledige codebase of met het uitbreiden van deze tutorial?
provider: deepseek
model: deepseek-chat
Zeker! Hier is een interactieve tutorial voor het maken van een REST API-eindpunt voor gebruikersregistratie met e-mailverificatie in Python met Amazon CodeWhisperer.
---
## **Stap 1: Projectopzet en vereisten**
### Benodigde packages:
```bash
pip install flask flask-sqlalchemy flask-mail flask-bcrypt jwt
```
### Basis projectstructuur:
```
/project
/app.py
/config.py
/templates/email_verification.html
```
---
## **Stap 2: Basis Flask App Configureren**
```python
# app.py
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail, Message
from flask_bcrypt import Bcrypt
import jwt
import datetime
import os
app = Flask(__name__)
# Basis configuratie
app.config['SECRET_KEY'] = 'jouw_geheime_sleutel'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# E-mail configuratie (voorbeeld voor Gmail)
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = 'jouw_email@gmail.com'
app.config['MAIL_PASSWORD'] = 'jouw_app_wachtwoord'
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
mail = Mail(app)
```
---
## **Stap 3: Gebruikersmodel Maken**
```python
# app.py (vervolg)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
is_verified = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def set_password(self, password):
self.password_hash = bcrypt.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password_hash, password)
def generate_verification_token(self):
token = jwt.encode(
{
'user_id': self.id,
'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=24)
},
app.config['SECRET_KEY'],
algorithm='HS256'
)
return token
```
---
## **Stap 4: Registratie-eindpunt Maken**
```python
# app.py (vervolg)
@app.route('/register', methods=['POST'])
def register():
try:
data = request.get_json()
# Validatie
if not data or not data.get('email') or not data.get('password'):
return jsonify({'error': 'E-mail en wachtwoord zijn verplicht'}), 400
# Controleren of gebruiker al bestaat
if User.query.filter_by(email=data['email']).first():
return jsonify({'error': 'E-mailadres is al in gebruik'}), 409
# Nieuwe gebruiker aanmaken
new_user = User(email=data['email'])
new_user.set_password(data['password'])
db.session.add(new_user)
db.session.commit()
# Verificatietoken genereren en e-mail versturen
token = new_user.generate_verification_token()
send_verification_email(new_user.email, token)
return jsonify({
'message': 'Registratie succesvol! Controleer je e-mail voor verificatie.',
'user_id': new_user.id
}), 201
except Exception as e:
db.session.rollback()
return jsonify({'error': 'Registratie mislukt'}), 500
def send_verification_email(email, token):
verification_url = f"http://localhost:5000/verify-email?token={token}"
msg = Message(
'Verifieer je e-mailadres',
sender='noreply@jouwapp.com',
recipients=[email]
)
msg.body = f'''
Bedankt voor je registratie!
Klik op de volgende link om je e-mailadres te verifiëren:
{verification_url}
Deze link is 24 uur geldig.
'''
mail.send(msg)
```
---
## **Stap 5: E-mailverificatie-eindpunt Maken**
```python
# app.py (vervolg)
@app.route('/verify-email', methods=['GET'])
def verify_email():
token = request.args.get('token')
if not token:
return jsonify({'error': 'Verificatietoken ontbreekt'}), 400
try:
# Token decoderen
payload = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
user_id = payload['user_id']
# Gebruiker vinden en verifiëren
user = User.query.get(user_id)
if not user:
return jsonify({'error': 'Ongeldige token'}), 400
if user.is_verified:
return jsonify({'message': 'E-mailadres is al geverifieerd'}), 200
user.is_verified = True
db.session.commit()
return jsonify({'message': 'E-mailadres succesvol geverifieerd!'}), 200
except jwt.ExpiredSignatureError:
return jsonify({'error': 'Verificatielink is verlopen'}), 400
except jwt.InvalidTokenError:
return jsonify({'error': 'Ongeldige verificatielink'}), 400
```
---
## **Stap 6: Database Initialiseren en App Starten**
```python
# app.py (vervolg)
if __name__ == '__main__':
with app.app_context():
db.create_all() # Creëert de database tabellen
app.run(debug=True)
```
---
## **Stap 7: Testen met cURL**
### Registratie testen:
```bash
curl -X POST http://localhost:5000/register \
-H "Content-Type: application/json" \
-d '{"email": "test@voorbeeld.nl", "password": "wachtwoord123"}'
```
### Verificatie testen (kopieer de token uit de e-mail):
```bash
curl "http://localhost:5000/verify-email?token=JOUW_TOKEN_HIER"
```
---
## **Veelvoorkomende Valkuilen en Oplossingen**
### **1. E-mail configuratie problemen**
```python
# FOUT: Verkeerde SMTP instellingen
# OPLOSSING: Gebruik de juiste poort en TLS
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
```
### **2. Wachtwoord hashing vergeten**
```python
# FOUT: Wachtwoord opslaan als plain text
user.password = password # ❌ NOOIT DOEN!
# OPLOSSING: Altijd hashen
user.set_password(password) # ✅ VEILIG
```
### **3. Token veiligheid**
```python
# FOUT: Zwakke secret key
app.config['SECRET_KEY'] = 'simple' # ❌ TE MAKKELIJK
# OPLOSSING: Sterke, willekeurige key
import secrets
app.config['SECRET_KEY'] = secrets.token_hex(32) # ✅ VEILIG
```
### **4. Database transacties vergeten**
```python
# FOUT: Geen error handling bij database operaties
db.session.add(new_user)
db.session.commit() # ❌ KAN FOUTEN GEVEN
# OPLOSSING: Gebruik try-except
try:
db.session.add(new_user)
db.session.commit()
except Exception as e:
db.session.rollback() # ✅ VOORKOMT DATABASE CORRUPTIE
```
---
## **Tips voor CodeWhisperer Gebruik**
1. **Specifieke comments schrijven**:
```python
# Maak een functie om wachtwoordsterkte te controleren
# CodeWhisperer zal suggesties geven voor implementatie
```
2. **Foutafhandeling verbeteren**:
```python
# Voeg gedetailleerde error logging toe
import logging
logging.basicConfig(level=logging.INFO)
```
3. **Extra functionaliteit toevoegen**:
```python
# Maak een endpoint om verificatie-e-mail opnieuw te versturen
# CodeWhisperer helpt met het implementeren
```
---
## **Volgende Stappen**
1. Voeg rate limiting toe om spam te voorkomen
2. Implementeer wachtwoord reset functionaliteit
3. Voeg logging toe voor betere debugging
4. Gebruik environment variables voor gevoelige data
5. Schrijf unit tests voor alle endpoints
**Belangrijk**: Vergeet niet om de e-mailconfiguratie aan te passen naar jouw e-mailprovider en gebruik environment variables voor gevoelige informatie zoals wachtwoorden en API keys!
Succes met je project! 🚀