Ejecución de queries

Para dejar un poco mas claro el codigo del update y no hacer una linea tan larga, se pueden almacenar los valores de los parametros de update_one en variables, de la siguiente manera:

filter = {"_id":ObjectId(curso["_id"])}
set = {'$set':{'nombre':curso['nombre'], 'descripcion':curso['descripcion'],'clases':curso['clases']}}

Asi al hacer el update solo se hace

db.cursos.update_one(filter, set).modified_count

5:30 el problema de copiar y pegar código, una mala práctica.

Código del “Actualizar_curso”:

str(db.cursos.update_one({'_id': ObjectId(curso['_id'])}, {'$set': {'nombre': curso['nombre'], 'descripcion': curso['descripcion'], 'clases': curso['clases']}}).modified_count)

Profesor, no solo copies y pegues

{
	"nombre": "Fundamentos AWS",
	"description": "Aprenderas a desplegar soluciones en la nube AWS",
	"clases": [
			{
				"orden": 1,
				"nombre": "Clase 1",
				"descripcion": "Descripcion de la clase 1",
				"video": "https://youtube.com"
			},
			{
				"orden": 2,
				"nombre": "Clase 2",
				"descripcion": "Descripcion de la clase 1",
				"video": "https://youtube.com"
			},
			{
				"orden": 3,
				"nombre": "Clase 3",
				"descripcion": "Descripcion de la clase 1",
				"video": "https://youtube.com"
			},
			{
				"orden": 4,
				"nombre": "Clase 4",
				"descripcion": "Descripcion de la clase 1",
				"video": "https://youtube.com"
			}
		]
}```

en el caso de los esquemas, como se pueden definir mejor?, el profesor los definió pero no es que se usen obligatoriamente no? osea lo digo porque, al momento de crear un nuevo curso lo hace mediante postman y la estructura del json viene definida como se había acordado anteriormente, pero si uno quiere, la puede cambiar sin problemas no?

mi pregunta es, hay alguna manera de poner un poco de “orden” al momento de definir cual será nuestra estructura(esquema) de los documentos??, tal vez con un example.json en el cual definimos como son las estructuras de los documentos? para de esa manera dejarle claro a otros desarrolladores como esta definida la estructura.

todo esto lo pregunto porque estaba viendo un tutorial en youtube en donde en vez de usar el modulo nativo de mongodb para nodejs usaban una librería llamada mongoose , y había una parte en la cual se definía el esquema con mongoose donde incluso se ponía que tipo de dato se esperaba, esto no lo he visto aún en el modulo nativo de mongodb para nodejs.

y la duda me surge debido a que , ¿ no se supone que mongodb es una base de datos sin esquemas ? , en la cual los documentos lo podemos ir guardando con la estructura que queramos no importa si la cambiamos, asi que, para retomar mi pregunta… , cual sería la mejor manera de mantener o por lo menos tratar de mantener un esquema para cierto tipo de documentos json ? , de tal manera que yo en un futuro u otros desarrolladores puedan ver facilmente como estan estructurados los documentos.

espero alguien me saque de dudas jeje, saludos y gracias de antemano

Me esta agradando phyton, nunca lo he trabajado, y veo que tiempo de conocernos jeje!

Curso muy complicado de seguir, el .json copiado a postman, no está tal cual se diseñó en la clase anterior, en un video previo se ha atribuído un fallo a la sintaxis de un (_id), pero en esa misma línea había otro error, el cual se ha editado en el vídeo y no se ha mencionado en la clase…Personalmente voy a terminarlo, pero sé que voy a tener que buscar en otras plataformas y documentación para poder aprender mongodb en condiciones.

A pesar de realizar la instalación de todas las herramientas de forma exitosa, me esta generando el siguiente error, cuando llamo a http://127.0.0.1:5000/

ALGUNA SOLUCION AL RESPECTO?. .

builtins.ModuleNotFoundError
ModuleNotFoundError: No module named ‘bson’

Traceback (most recent call last)
File “/home/jmsg78/anaconda3/lib/python3.7/site-packages/flask/cli.py”, line 76, in find_best_app
app = call_factory(script_info, app_factory)
File “/home/jmsg78/anaconda3/lib/python3.7/site-packages/flask/cli.py”, line 116, in call_factory
return app_factory()
File “/home/jmsg78/platzi-mongo/platzi-api/init.py”, line 24, in create_app
from . import carreras,cursos
File “/home/jmsg78/platzi-mongo/platzi-api/carreras.py”, line 2, in <module>
from . import db
File “/home/jmsg78/platzi-mongo/platzi-api/db.py”, line 1, in <module>
from bson.json_util import dumps, ObjectId
ModuleNotFoundError: No module named 'bson’
The debugger caught an exception in your WSGI application. You can now look at the traceback which led to the error.
To switch between the interactive traceback and the plaintext one, you can click on the “Traceback” headline. From the text traceback you can also create a paste of it. For code execution mouse-over the frame you want to debug and click on the console icon on the right side.

You can execute arbitrary Python code in the stack frames and there are some extra helpers available for introspection:

from flask import Flask
from flask import request
from pymongo import MongoClient
from bson.json_util import dumps
from bson import ObjectId
import json

# client = MongoClient('localhost:27017')
client = MongoClient(
    'mongodb+srv://[usuario]:[clave]@curso-platzi-kuuzl.mongodb.net/test')
db = client.platzi

app = Flask(__name__)


@app.route("/")
def hello():
    return "Welcome to Python Flask! platzi-mongo2"

# CREATE CARRERA
@app.route("/carreras", methods=['POST'])
def create_carrera():
    try:
        data = json.loads(request.data)
        nombre = data['nombre']
        descripcion = data['descripcion']
        if nombre and descripcion:
            # status = db.carreras.insert_one(data)
            # return dumps({'message' : 'SUCCESS'})
            return dumps(db.carreras.insert_one(data).inserted_id)
    except Exception as e:
        return dumps({'error': str(e)})

# READ TODAS LAS CARRERAS
@app.route("/carreras", methods=['GET'])
def read_carrera():
    try:
        carreras = db.carreras.find()
        return dumps(carreras)
    except Exception as e:
        return dumps({'error': str(e)})

# READ UNA CARRERA POR id
@app.route("/carreras/<id>", methods=['GET'])
def read_carrera_id(id):
    try:
        pageid = id
        return dumps(db.carreras.find_one({'_id': ObjectId(pageid)}))
    except Exception as e:
        return dumps({'error': str(e)})

# UPDATE CARRERA
@app.route("/carreras", methods=['PUT'])
def update_carrera():
    try:
        data = json.loads(request.data)
        nombre = data['nombre']
        _id = data['_id']
        descripcion = data['descripcion']
        if nombre and descripcion:
            status = db.carreras.update_one({'_id': ObjectId(_id)}, {
                                            '$set': {'nombre': nombre, 'descripcion': descripcion}})
            return str(status.modified_count)
    except Exception as e:
        return dumps({'error': str(e)})

# DELETE UNA CARRERA POR id
@app.route("/carreras/<id>", methods=['DELETE'])
def delete_carrera_id(id):
    try:
        pageid = id
        status = db.carreras.delete_one({'_id': ObjectId(pageid)})
        return str(status.deleted_count)
    except Exception as e:
        return dumps({'error': str(e)})


# home function
@app.route('/profile/<int:id>')
def myProfile(id):
    return 'The project page ' + str(id)


# CREATE CURSO
@app.route("/cursos", methods=['POST'])
def create_curso():
    try:
        data = json.loads(request.data)
        nombre = data['nombre']
        descripcion = data['descripcion']
        if nombre and descripcion:
            # id = str(db.cursos.insert_one(data).inserted_id)
            # return dumps({"_id":id})
            return dumps(db.cursos.insert_one(data).inserted_id)
    except Exception as e:
        return dumps({'error': str(e)})

# READ TODAS LOS CURSOS
@app.route("/cursos", methods=['GET'])
def read_curso():
    try:
        cursos = db.cursos.find()
        return dumps(cursos)
    except Exception as e:
        return dumps({'error': str(e)})

# READ UN CURSO POR id
@app.route("/cursos/<id>", methods=['GET'])
def read_curso_id(id):
    try:
        pageid = id
        return dumps(db.cursos.find_one({'_id': ObjectId(pageid)}))
    except Exception as e:
        return dumps({'error': str(e)})

# UPDATE CURSO
@app.route("/cursos", methods=['PUT'])
def update_curso():
    try:
        data = json.loads(request.data)
        _id = data['_id']
        nombre = data['nombre']
        descripcion = data['descripcion']
        # eliminar _id del JSON para que no genere un error al actualizar
        del data['_id']
        filtro = {'_id': ObjectId(_id)}
        actualizar = {'$set': data}
        if nombre and descripcion:
            status = db.cursos.update_one(filtro, actualizar)
            return str(status.modified_count)
    except Exception as e:
        return dumps({'error': str(e)})

# DELETE UN CURSO POR id
@app.route("/cursos/<id>", methods=['DELETE'])
def delete_curso_id(id):
    try:
        pageid = id
        status = db.cursos.delete_one({'_id': ObjectId(pageid)})
        return str(status.deleted_count)
    except Exception as e:
        return dumps({'error': str(e)})

Funciones:

def crear_curso(json):
    return str(db.cursos.insert_one(json).inserted_id)


def consultar_curso_por_id(id_curso):
    #(dumps para convertir de bson a json)
    return dumps(db.cursos.find_one({'_id': ObjectId('id_curso')}))


def actualizar_curso(curso):
    # Esta funcion solamente actualiza nombre, descripcion y clases del curso
    return str(db.cursos.update_one({'_id': ObjectId(curso['_id'])}, {'$set': {'nombre': curso['nombre'], 'descripcion': curso['descripcion'], 'clases': curso['clases']}}).modified_count)


def borrar_curso_por_id(curso_id):
    return str(db.cursos.delete_one({'_id': ObjectId(curso_id)}).deleted_count)

Para el actualizar curso tambien podemos usar python para que el codigo quede mas limpio, haciendo uso de los args, kwargs y pop, quedaria algo asi:

return str(
        db.cursos.update_one(
            {"_id": ObjectId(curso.pop("_id"))},
            {"$set": {**curso}},
        ).modified_count
    )

Aquí pueden encontrar un ejemplo y una explicación que le puede complementar:

https://jarroba.com/python-mongodb-driver-pymongo-con-ejemplos/

Entendido

Si bien, comenzar este proyecto fue un copy paste porque toca temas que no son el foco del curso, es muy interesante ver como funciona un driver como pymongo y como podemos implementar queries dentro de nuestro código de backend.

Si tengo una colección, con una estructura grande y elaborada, al momento de realizar una actualización de ciertos datos, ¿Es conveniente tener distintos servicios que actualicen cada cierta información en mi documento o es mejor tener una sola?,¿Cual sería lo mas optimo y recomendable?..
Me dieron un proyecto, y en ocasiones hago operaciones tan básicas como actualizar un dato de cierta colección … pero la estructura es inmensa… y vi que los servicios de actualización envían todo el cuerpo…si lo llevo a nivel SQL me parece no optimo.

Entendido y funciono correctamente.

Como puedo crear consultas o hacer modificaciones sobre arrays anidados?

entendido, gracias

Excelente ejercicio

Cuando ejecuten el verbo _**Put **_tengan cuidado de no copiar exacatmente el resultado devuelto por Get, ya que cambia el objeto json en unas cuantas cosas como que todo está incluido dentro de un documento clase y que el id tiene un campo extra por el object id, eso me tomo 1 hora descubrirlo .