Genereer contextbewuste codevoorstellen met CodeWhisperer
description
Met deze prompt krijg je gerichte en contextspecifieke codevoorstellen van CodeWhisperer, afgestemd op jouw projectbeschrijving. Dit verhoogt de productiviteit door praktische codevoorbeelden te bieden die aansluiten bij best practices, en gaat verder dan generieke suggesties.
prompt
Gebruik Amazon CodeWhisperer om contextbewuste codevoorstellen voor mijn project te genereren op basis van de volgende beschrijving: <proj ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een voorbeeld van code voor een REST API in Python voor het beheren van gebruikersgegevens met authenticatie, inclusief best practices en efficiënte implementaties:
```python
from flask import Flask, request, jsonify, make_response
from flask_sqlalchemy import SQLAlchemy
from werkzeug.security import generate_password_hash, check_password_hash
import jwt
import datetime
from functools import wraps
app = Flask(__name__)
app.config['SECRET_KEY'] = 'jouw_zeer_veilige_secret_key'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///gebruikers.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
# Gebruikersmodel
class Gebruiker(db.Model):
id = db.Column(db.Integer, primary_key=True)
gebruikersnaam = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
wachtwoord_hash = db.Column(db.String(128), nullable=False)
def set_wachtwoord(self, wachtwoord):
self.wachtwoord_hash = generate_password_hash(wachtwoord)
def check_wachtwoord(self, wachtwoord):
return check_password_hash(self.wachtwoord_hash, wachtwoord)
# Decorator voor authenticatie
def token_required(f):
@wraps(f)
def decorator(*args, **kwargs):
token = None
# Token wordt vaak in de headers meegegeven
if 'x-access-tokens' in request.headers:
token = request.headers['x-access-tokens']
if not token:
return jsonify({'message': 'Token ontbreekt!'}), 401
try:
data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=["HS256"])
current_gebruiker = Gebruiker.query.filter_by(id=data['id']).first()
except:
return jsonify({'message': 'Ongeldig token!'}), 401
return f(current_gebruiker, *args, **kwargs)
return decorator
# Registratie endpoint
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
if not data or not 'gebruikersnaam' in data or not 'email' in data or not 'wachtwoord' in data:
return jsonify({'message': 'Ongeldige gegevens!'}), 400
if Gebruiker.query.filter_by(gebruikersnaam=data['gebruikersnaam']).first() or \
Gebruiker.query.filter_by(email=data['email']).first():
return jsonify({'message': 'Gebruikersnaam of email bestaat al!'}), 409
nieuwe_gebruiker = Gebruiker(
gebruikersnaam=data['gebruikersnaam'],
email=data['email']
)
nieuwe_gebruiker.set_wachtwoord(data['wachtwoord'])
db.session.add(nieuwe_gebruiker)
db.session.commit()
return jsonify({'message': 'Gebruiker succesvol geregistreerd!'}), 201
# Login endpoint
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
if not data or not 'gebruikersnaam' in data or not 'wachtwoord' in data:
return jsonify({'message': 'Ongeldige gegevens!'}), 400
gebruiker = Gebruiker.query.filter_by(gebruikersnaam=data['gebruikersnaam']).first()
if niet gebruiker of niet gebruiker.check_wachtwoord(data['wachtwoord']):
return jsonify({'message': 'Onjuiste gebruikersnaam of wachtwoord!'}), 401
token = jwt.encode({
'id': gebruiker.id,
'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=2)
}, app.config['SECRET_KEY'], algorithm="HS256")
return jsonify({'token': token})
# Endpoint om gebruikersgegevens op te halen (beveiligd)
@app.route('/gebruikers/<int:id>', methods=['GET'])
@token_required
def get_gebruiker(current_gebruiker, id):
if current_gebruiker.id != id:
return jsonify({'message': 'Geen toegang!'}), 403
gebruiker = Gebruiker.query.get_or_404(id)
return jsonify({
'id': gebruiker.id,
'gebruikersnaam': gebruiker.gebruikersnaam,
'email': gebruiker.email
})
# Endpoint om gebruikersgegevens bij te werken
@app.route('/gebruikers/<int:id>', methods=['PUT'])
@token_required
def update_gebruiker(current_gebruiker, id):
if current_gebruiker.id != id:
return jsonify({'message': 'Geen toegang!'}), 403
data = request.get_json()
gebruiker = Gebruiker.query.get_or_404(id)
if 'email' in data:
gebruiker.email = data['email']
if 'wachtwoord' in data:
gebruiker.set_wachtwoord(data['wachtwoord'])
db.session.commit()
return jsonify({'message': 'Gegevens bijgewerkt!'})
# Main
if __name__ == '__main__':
db.create_all()
app.run(debug=True)
```
**Belangrijk:**
- Gebruik een sterke, unieke SECRET_KEY in productie.
- Overweeg het gebruik van HTTPS voor beveiligde communicatie.
- Behandel gebruikersgegevens altijd vertrouwelijk en volgens privacyregels.
- Implementeer extra beveiligingsmaatregelen zoals rate limiting en inputvalidatie indien nodig.
provider: deepseek
model: deepseek-chat
Hier is een voorbeeldimplementatie van een REST API voor gebruikersbeheer met authenticatie in Python met behulp van Flask en best practices:
```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity
import datetime
import os
# Initialisatie
app = Flask(__name__)
# Configuratie
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///users.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['JWT_SECRET_KEY'] = os.getenv('JWT_SECRET', 'jouw_veilige_secret_key_hier')
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = datetime.timedelta(hours=1)
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
jwt = JWTManager(app)
# Gebruikersmodel
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(120), nullable=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)
# Routes
@app.route('/api/register', methods=['POST'])
def register():
try:
data = request.get_json()
# Validatie
if not data or not data.get('username') or not data.get('email') or not data.get('password'):
return jsonify({'error': 'Ontbrekende vereiste velden'}), 400
# Controleer of gebruiker al bestaat
if User.query.filter_by(username=data['username']).first():
return jsonify({'error': 'Gebruikersnaam bestaat al'}), 409
if User.query.filter_by(email=data['email']).first():
return jsonify({'error': 'E-mailadres bestaat al'}), 409
# Maak nieuwe gebruiker aan
new_user = User(
username=data['username'],
email=data['email']
)
new_user.set_password(data['password'])
db.session.add(new_user)
db.session.commit()
return jsonify({
'message': 'Gebruiker succesvol aangemaakt',
'user_id': new_user.id
}), 201
except Exception as e:
return jsonify({'error': str(e)}), 500
@app.route('/api/login', methods=['POST'])
def login():
try:
data = request.get_json()
if not data or not data.get('username') or not data.get('password'):
return jsonify({'error': 'Gebruikersnaam en wachtwoord vereist'}), 400
user = User.query.filter_by(username=data['username']).first()
if user and user.check_password(data['password']):
access_token = create_access_token(identity=user.id)
return jsonify({
'access_token': access_token,
'user_id': user.id,
'username': user.username
}), 200
return jsonify({'error': 'Ongeldige inloggegevens'}), 401
except Exception as e:
return jsonify({'error': str(e)}), 500
@app.route('/api/users/<int:user_id>', methods=['GET'])
@jwt_required()
def get_user(user_id):
try:
current_user_id = get_jwt_identity()
if current_user_id != user_id:
return jsonify({'error': 'Toegang geweigerd'}), 403
user = User.query.get_or_404(user_id)
return jsonify({
'id': user.id,
'username': user.username,
'email': user.email,
'created_at': user.created_at.isoformat()
}), 200
except Exception as e:
return jsonify({'error': str(e)}), 500
@app.route('/api/users/<int:user_id>', methods=['PUT'])
@jwt_required()
def update_user(user_id):
try:
current_user_id = get_jwt_identity()
if current_user_id != user_id:
return jsonify({'error': 'Toegang geweigerd'}), 403
user = User.query.get_or_404(user_id)
data = request.get_json()
if 'email' in data:
user.email = data['email']
if 'password' in data:
user.set_password(data['password'])
db.session.commit()
return jsonify({'message': 'Gebruiker succesvol bijgewerkt'}), 200
except Exception as e:
return jsonify({'error': str(e)}), 500
# Foutafhandeling
@app.errorhandler(404)
def not_found(error):
return jsonify({'error': 'Resource niet gevonden'}), 404
@app.errorhandler(500)
def internal_error(error):
return jsonify({'error': 'Interne serverfout'}), 500
# Database initialisatie
with app.app_context():
db.create_all()
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000)
```
**Vereiste dependencies (requirements.txt):**
```txt
Flask==2.3.3
Flask-SQLAlchemy==3.0.5
Flask-Bcrypt==1.0.1
Flask-JWT-Extended==4.5.2
python-dotenv==1.0.0
```
**Best practices geïmplementeerd:**
1. JWT-based authenticatie
2. Wachtwoordhashing met bcrypt
3. Inputvalidatie
4. Foutafhandeling
5. Environment variables voor configuratie
6. SQL-injectie preventie via ORM
7. Proper HTTP status codes
8. Token expiration
9. Gebruikersautorizatie
**Gebruik:**
```bash
# Installatie
pip install -r requirements.txt
# Starten
python app.py
```
Deze implementatie volgt REST principles en bevat essentiële security features voor gebruikersbeheer.