Métodos POST

Manejo de request.json

Cuando trabajamos con métodos POST en Flask, la información que recibimos del cliente suele llegar en formato JSON dentro del cuerpo de la petición HTTP. Flask proporciona el objeto request.json que nos permite acceder directamente a estos datos de manera sencilla y eficiente.

El objeto request.json es una propiedad especial que automáticamente parsea el contenido JSON del cuerpo de la petición y lo convierte en un diccionario de Python. Esto significa que podemos trabajar con los datos recibidos utilizando la sintaxis familiar de diccionarios, sin necesidad de realizar conversiones manuales.

Acceso básico a datos JSON

Para acceder a los datos JSON enviados en una petición POST, simplemente utilizamos request.json como si fuera un diccionario normal:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/usuarios', methods=['POST'])
def crear_usuario():
    # Acceder a los datos JSON enviados
    nombre = request.json['nombre']
    email = request.json['email']
    edad = request.json['edad']
    
    # Procesar los datos (ejemplo: crear usuario en memoria)
    nuevo_usuario = {
        'id': 1,
        'nombre': nombre,
        'email': email,
        'edad': edad
    }
    
    return jsonify(nuevo_usuario), 201

En este ejemplo, el cliente debe enviar una petición POST con un cuerpo JSON similar a:

{
    "nombre": "Ana García",
    "email": "ana@ejemplo.com",
    "edad": 28
}

Validación de datos JSON

Es fundamental validar que los datos JSON estén presentes y sean del tipo esperado antes de procesarlos. Flask nos permite verificar si la petición contiene JSON válido:

@app.route('/productos', methods=['POST'])
def crear_producto():
    # Verificar que la petición contiene JSON
    if not request.is_json:
        return jsonify({'error': 'Content-Type debe ser application/json'}), 400
    
    # Verificar que request.json no es None
    if request.json is None:
        return jsonify({'error': 'Cuerpo JSON requerido'}), 400
    
    # Validar campos obligatorios
    campos_requeridos = ['nombre', 'precio', 'categoria']
    for campo in campos_requeridos:
        if campo not in request.json:
            return jsonify({'error': f'Campo {campo} es obligatorio'}), 400
    
    # Procesar datos validados
    producto = {
        'id': 123,
        'nombre': request.json['nombre'],
        'precio': float(request.json['precio']),
        'categoria': request.json['categoria']
    }
    
    return jsonify(producto), 201

Manejo seguro con get()

Para evitar errores cuando un campo no existe en el JSON, podemos utilizar el método get() que nos permite especificar valores por defecto:

@app.route('/configuracion', methods=['POST'])
def actualizar_configuracion():
    if not request.is_json:
        return jsonify({'error': 'JSON requerido'}), 400
    
    # Usar get() con valores por defecto
    configuracion = {
        'tema': request.json.get('tema', 'claro'),
        'idioma': request.json.get('idioma', 'es'),
        'notificaciones': request.json.get('notificaciones', True),
        'limite_resultados': request.json.get('limite_resultados', 10)
    }
    
    return jsonify({
        'mensaje': 'Configuración actualizada',
        'configuracion': configuracion
    })

Trabajando con estructuras JSON complejas

Flask maneja automáticamente estructuras JSON anidadas, listas y objetos complejos:

@app.route('/pedidos', methods=['POST'])
def crear_pedido():
    if not request.is_json:
        return jsonify({'error': 'JSON requerido'}), 400
    
    # Acceder a datos anidados
    cliente = request.json.get('cliente', {})
    items = request.json.get('items', [])
    
    # Validar estructura del cliente
    if not cliente.get('nombre') or not cliente.get('email'):
        return jsonify({'error': 'Datos del cliente incompletos'}), 400
    
    # Procesar lista de items
    total = 0
    for item in items:
        if 'precio' in item and 'cantidad' in item:
            total += item['precio'] * item['cantidad']
    
    pedido = {
        'id': 456,
        'cliente': {
            'nombre': cliente['nombre'],
            'email': cliente['email'],
            'telefono': cliente.get('telefono', '')
        },
        'items': items,
        'total': total
    }
    
    return jsonify(pedido), 201

Este endpoint esperaría un JSON como:

{
    "cliente": {
        "nombre": "Carlos López",
        "email": "carlos@ejemplo.com",
        "telefono": "123456789"
    },
    "items": [
        {"nombre": "Producto A", "precio": 25.50, "cantidad": 2},
        {"nombre": "Producto B", "precio": 15.00, "cantidad": 1}
    ]
}

Validación de tipos de datos

Es importante verificar los tipos de los datos recibidos para evitar errores en tiempo de ejecución:

@app.route('/calificaciones', methods=['POST'])
def agregar_calificacion():
    if not request.is_json:
        return jsonify({'error': 'JSON requerido'}), 400
    
    try:
        # Validar y convertir tipos
        estudiante_id = int(request.json.get('estudiante_id'))
        materia = str(request.json.get('materia', '')).strip()
        nota = float(request.json.get('nota'))
        
        # Validar rangos
        if not (0 <= nota <= 10):
            return jsonify({'error': 'La nota debe estar entre 0 y 10'}), 400
        
        if not materia:
            return jsonify({'error': 'Materia no puede estar vacía'}), 400
        
        calificacion = {
            'id': 789,
            'estudiante_id': estudiante_id,
            'materia': materia,
            'nota': nota,
            'aprobado': nota >= 5.0
        }
        
        return jsonify(calificacion), 201
        
    except (ValueError, TypeError):
        return jsonify({'error': 'Tipos de datos inválidos'}), 400
    except KeyError as e:
        return jsonify({'error': f'Campo requerido: {str(e)}'}), 400

El manejo adecuado de request.json es esencial para crear APIs REST robustas que puedan procesar datos de manera segura y eficiente, proporcionando respuestas apropiadas tanto para casos exitosos como para errores de validación.