25_Django_PyMongo.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "25-Django_PyMongo.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPvqeNbSImxXln/dIWqfSJK",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/arleserp/MinTIC2022/blob/master/25_Django_PyMongo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lMSmpXRsQ-VK"
      },
      "source": [
        "# MinTIC2020 Ciclo 1\n",
        "Bienvenido al repositorio que contiene el ejercicio de cierre del Ciclo 1 de MisiónTIC 2022 del Gobierno de Colombia.\n",
        "En este ejercicio usted realizará un paso a paso en donde usando los conocimientos aprendidos en python, nuevas cosas que va a aprender, y algunos elementos previamente construidos por sus profesores, creara un versión bastante sencilla de una Tienda Virtual.\n",
        "De esta manera, usted podrá ver de una forma directa como utilizar los conceptos que aprendió en este ciclo, además de evidenciar la importancia del trabajo en equipo con otros roles tradicionales (como el caso de los desarrolladores front-end) en la conformación de equipos de desarrollo de software.\n",
        "\n",
        "\n",
        "## Pre-requisitos \n",
        "Tener MongoBD instalado, y la ejecución del Daemon de Mongo durante el tiempo del ejercicio. Adicionalmente, haber ajustado las vistas, plantillas, formularios y mapeo del proyecto de **Django**.\n",
        "\n",
        "\n",
        "\n",
        "## PyMongo y Transacciones con la Base de Datos\n",
        "Una vez se tiene la aplicación construida en su base fundamental, lo que incluye el MVC, formularios, y la interacción con el `HTML` solo falta un elemento adicional: las transacciones con la Base de Datos. Es importante tener instalado `MongoDB` para completar el ejercicio, además de tener en ejecuci\\'on el `mongod`, o como también se le ha mencionado, el `mongo servidr`.\n",
        "\n",
        "Por un lado, para la información que se quiera presentar en los `HTML` y se cargue desde la base de datos, las transacciones deben ser realizadas en el archivo `views.py`, en donde están las funciones que conectan las _vistas_ con los _templates_. En este sentido, en la función que corresponda se debe agregar la información obtenida de la base de datos a una lista, que será enviada como un parámetro.\n",
        "\n",
        "Para este ejercicio, las siguientes son las modificaciones que se deben realizar para completar las transacciones con la base de datos, y por consiguiente, completar la aplicación en su primera versión:\n",
        "1. Ir a `MongoDB`, mejor conocido como `mongo cliente`, y crear una base de datos para el ejercicio; en este caso, se crea una base de datos de nombre `tiendaVirtual`. En esta base de datos, es necesario que usted cree tres colecciones: (i) _productos_, (ii) _compras_, y (iii) _carrito_. En la consola de `MongoDB` sería algo similar a la siguiente secuencia de instrucciones:\n",
        "```\n",
        "use tiendaVirtual\n",
        "db.createCollection('productos')\n",
        "db.createCollection('compras')\n",
        "db.createCollection('carrito')\n",
        "```\n",
        "2. Para poblar la base de datos inicialmente, en la carpeta de la aplicación, `tienda_virtual` en este caso, cree un archivo `basedatos_inicial.py`. En este archivo puede generar datos ficticios y almacenarlos en la base de datos, para que su **Tienda Virtual** funcione como usted desea. \n",
        "A continuación se le coloca el código que le sirve para conectarse con el cliente de mongo a la base de datos:\n",
        "```\n",
        "from pymongo import MongoClient\n",
        "client = MongoClient('mongodb://localhost:27017/')\n",
        "db_tienda_virtual = client.tiendaVirtual\n",
        "```\n",
        "\n",
        "Este código debe estar al inicio del archivo. Ahora, para crear un listado inicial de productos, en este archivo, podría utilizar un fragmento de código similar al que se presenta a continuación:\n",
        "```\n",
        "lista_inicial = [\n",
        "\t{'nombre': \"Balón\", 'costo': 10000},\n",
        "\t{'nombre': \"Chaqueta\", 'costo': 85000},\n",
        "\t{'nombre': \"Libro\", 'costo': 12000},\n",
        "\t{'nombre': \"Pantalón\", 'costo': 90000},\n",
        "\t{'nombre': \"Computador\", 'costo': 2500000},\n",
        "\t{'nombre': \"Silla\", 'costo': 400000},\n",
        "\t{'nombre': \"Celular\", 'costo': 1250000},\n",
        "\t{'nombre': \"Raqueta\", 'costo': 250000},\n",
        "\t{'nombre': \"Tablet\", 'costo': 600000},\n",
        "\t{'nombre': \"Mesa\", 'costo': 172000},\n",
        "\t{'nombre': \"Camiseta\", 'costo': 28000},\n",
        "\t{'nombre': \"Cámara\", 'costo': 2450000},\n",
        "\t{'nombre': \"Billetera\", 'costo': 62000},\n",
        "\t{'nombre': \"Sofá\", 'costo': 450000},\n",
        "\t{'nombre': \"Alcancia\", 'costo': 15000}\n",
        "]\n",
        "\n",
        "db_tienda_virtual.productos.drop()\n",
        "ids_ = db_tienda_virtual.productos.insert_many(lista_inicial)\n",
        "print(ids_)\n",
        "```\n",
        "Para ejecutar este archivo, debe ir en la terminal a la carpeta de la aplicación, es decir, a `tienda_virtual`, y ejecuta la siguiente línea:\n",
        "```\n",
        "python basedatos_inicial.py\n",
        "```\n",
        "3. Invocar al cliente de `PyMongo` y hacer la conexión a la base de datos que usted haya definido en `MongoDB`. Esto debe hacerse antes de la declaración de las funciones dentro del archivo `views.py`, para que esta conexión esté definida en un alcance global del archivo:\n",
        "```\n",
        "client = MongoClient('mongodb://localhost:27017/')\n",
        "db_tienda_virtual = client.tiendaVirtual\n",
        "```\n",
        "4. La función `carrito` requiere cargar los elementos que estén en la colección del `carrito`, así que se debe generar el cursos y agregar los elementos a la lista `productos` que ya había sido definida como vacía. Así, usted deberá tener una función similar a la siguiente:\n",
        "```\n",
        "def carrito(request):\n",
        "    '''\n",
        "    Esta función indica la carga de la pantalla en la cual se visualiza el actual carrito de compras en la Tienda Virtual\n",
        "    '''\n",
        "    productos = []\n",
        "    cursor = db_tienda_virtual['carrito'].find()\n",
        "    for document in cursor:\n",
        "        temp = {}\n",
        "        temp['nombre'] = document['nombre']\n",
        "        temp['costo'] = document['costo_unidad']\n",
        "        temp['cantidad'] = document['cantidad']\n",
        "        productos.append(temp)\n",
        "\n",
        "    parametros = {'productos':  productos}\n",
        "    return render(request, 'tienda_virtual/carrito_compras.html', parametros)\n",
        "``` \n",
        "5. Similar al anterior numeral, en la función de `historial` se debe cargar la información contenida en la colección de `compras`. El proceso debe ser similar al de la función `carrito`. A continuación se muestra un ehjermplo de esta función:\n",
        "```\n",
        "def historial(request):\n",
        "    '''\n",
        "    Esta función indica la carga de la pantalla en la cual se podrá visualizar el historial de compras de la Tienda Virtual\n",
        "    '''\n",
        "    historial = []\n",
        "    cursor = db_tienda_virtual['compras'].find()\n",
        "    contador = 1\n",
        "    for document in cursor:\n",
        "        temp = {}\n",
        "        temp['numero'] = contador\n",
        "        temp['nombre'] = document['nombre_cliente']\n",
        "        temp['costo'] = document['costo']\n",
        "        temp['productos'] = document['productos']\n",
        "        temp['fecha'] = document['fecha']\n",
        "        temp['metodo'] = document['metodo_pago']\n",
        "        temp['observaciones'] = document['observaciones']\n",
        "        temp['direccion'] = document['direccion']\n",
        "        historial.append(temp)\n",
        "        contador += 1\n",
        "\n",
        "    parametros = {'historial':  historial}\n",
        "    return render(request, 'tienda_virtual/historial.html', parametros)\n",
        "```\n",
        "6. El formulario llamado _agregar\\_producto_ requiere cargar los productos disponibles en la base de datos. Es hora de usar `pymongo` para ello. En ese caso, usted debe instanciar el cliente de `MongoDB`, y obtener la información de la colección `productos`, para luego llenar la lista usando un ciclo `for`. Así, el siguiente sería un ejemplo de cómo quedaría definido el formulario:\n",
        "```\n",
        "class agregar_producto(Form):\n",
        "    '''\n",
        "    Este formulario corresponde a la opción de agregar productos al carrito de compras.\n",
        "    '''\n",
        "    client = MongoClient('mongodb://localhost:27017/')\n",
        "    db_tienda_virtual = client.tiendaVirtual\n",
        "    \n",
        "    cursor = db_tienda_virtual['productos'].find({}, {'nombre': 1})\n",
        "    productos = ((document['nombre'], document['nombre']) for document in cursor)\n",
        "    cantidad = ((i, i) for i in range(16))\n",
        "    \n",
        "    producto = ChoiceField(label = \"Producto\", required=True, choices=productos)\n",
        "    cantidad = ChoiceField(label = \"Cantidad\", required=True, choices=cantidad)\n",
        "```\n",
        "\n",
        "De esta manera, usted ahora ha integrado de manera exitosa `MongoDB` usando la librería `pymongo` con su aplicación de **Django**. Sin embargo, aún debemos hacer un par de pasos adicionales para completar la tarea...pero ya estamos cerca de acabar. \n",
        "\n",
        "## Manejo de Formularios\n",
        "En el archivo `views.py` existen dos vistas que hacen uso de formularios para enviar y recibir información de los templates. En ambos casos se requiere de un tratamiento especial.\n",
        "\n",
        "Aunque hay variaciones en cada función, el proceso general es similar:\n",
        "- Verificar si el formulario viene como parte de la petición del HTML, esto quiere decir que alguien diligencio el formulario en el navegador web.\n",
        "- Si el formulario no viene en la petición, se carga el template normal. En caso contrario, se debe almacenarla información del formulario en una variable de `python`.\n",
        "- Si el formulario viene en la petición, además de almacenar su valor, se deben extraer sus campos uno por uno, y hacer las operaciones que correspondan contra la base de datos.\n",
        "\n",
        "De manera particular, se tiene lo siguiente para cada función:\n",
        "1. La función de `productos` requiere que la información almacenada en la colección de `productos` sea cargada desde la base de datos, y así mostrar esa lista al usuario en la pantalla web. Adicionalmente, se debe verificar si el usuario escogió agregar un producto al carrito, en cuyo caso se valida el formulario, y se guarda el producto junto su costo por unidad y cantidad en el carrito de compras. Un ejemplo de la función `productos` actualiza sería el siguiente:\n",
        "```\n",
        "def productos(request):\n",
        "    '''\n",
        "    Esta función indica la carga de la pantalla que tiene el listado de productos que pueden ser agregados al carrito de la Tienda Virtual\n",
        "    '''\n",
        "    productos = []\n",
        "    cursor = db_tienda_virtual['productos'].find()\n",
        "    for document in cursor:\n",
        "        temp = {}\n",
        "        temp['nombre'] = document['nombre']\n",
        "        temp['costo'] = document['costo']\n",
        "        productos.append(temp)\n",
        "   \n",
        "    if request.method == 'POST': \n",
        "        frm_agregar = forms.agregar_producto(request.POST) \n",
        "\n",
        "        if frm_agregar.is_valid():\n",
        "            producto = {}\n",
        "            producto['nombre'] = request.POST.get('producto')\n",
        "            producto['cantidad'] = request.POST.get('cantidad')\n",
        "            \n",
        "            datos_producto = db_tienda_virtual['productos'].find({'nombre': producto['nombre']}, {'costo': 1})\n",
        "            producto['costo_unidad'] = datos_producto[0]['costo']\n",
        "            \n",
        "            db_tienda_virtual['carrito'].insert_one(producto)\n",
        "\n",
        "    frm_agregar = forms.agregar_producto()\n",
        "    parametros = {'frm_agregar':  frm_agregar, 'productos': productos}\n",
        "    return render(request, 'tienda_virtual/lista_productos.html', parametros)\n",
        "```\n",
        "\n",
        "2. La función de `pagos` necesita calcular el costo total de los elementos en el carrito para realizar el pago. En este caso, se necesita recorrer cada uno de los elementos en la colección de `carrito`, y calcular el pago total teniendo en cuenta los campos de `costo` y `cantidad`, esto utilizando un ciclo `for`. Adicionalmente, si el usuario ya hizo uso de la opción de pagar, se debe validar el formulario, obtener los campos diligenciados, calcular la fecha actual (se puede usar la librería `datetime` de `python`), y guardar la compra en el historial (además de vaciar el carrito de compras). Un ejemplo de esta función se muestra a continuación:\n",
        "```\n",
        "def pagos(request):\n",
        "    '''\n",
        "    Esta función indica la carga de la pantalla en la cual se realiza el Pago de los productos que estén en el carrito de la Tienda Virtual\n",
        "    '''\n",
        "    costo = 0\n",
        "    listado_productos = \"\"\n",
        "\n",
        "    cursor = db_tienda_virtual['carrito'].find()\n",
        "    for document in cursor:\n",
        "        costo += int(document['costo_unidad']) * int(document['cantidad'])\n",
        "        listado_productos +=  str(document['cantidad']) + ' ' + document['nombre'] + '\\n'\n",
        "\n",
        "    if request.method == 'POST': \n",
        "        frm_pago = forms.pagar_carrito(request.POST) \n",
        "\n",
        "        if frm_pago.is_valid():\n",
        "            pago = {}\n",
        "            pago['productos'] = listado_productos\n",
        "            pago['metodo_pago'] = request.POST.get('metodo_pago')\n",
        "            pago['nombre_cliente'] = request.POST.get('comprador')\n",
        "            pago['direccion'] = request.POST.get('direccion')\n",
        "            pago['observaciones'] = request.POST.get('observaciones')\n",
        "            pago['fecha'] = datetime.now().strftime(\"%d/%m/%Y\")\n",
        "            pago['costo'] = costo\n",
        "            print(pago)\n",
        "\n",
        "            costo = 0\n",
        "            \n",
        "            db_tienda_virtual['carrito'].drop()\n",
        "            db_tienda_virtual['compras'].insert_one(pago)\n",
        "\n",
        "    frm_pago = forms.pagar_carrito()\n",
        "    \n",
        "    parametros = {'frm_pago':  frm_pago, 'costo': costo}\n",
        "    return render(request, 'tienda_virtual/pagar.html', parametros)\n",
        "```\n",
        "\n",
        "Para que la captura de la fecha de la compra funcione, debe hacer una importación al inicio del archivo `views.py`, la cual es: `from datetime import datetime`. \n",
        "\n",
        "Nos falta un último paso. Se ha hecho una mejora de presentación de un par de cosas a nivel de los templates, así que se ha generado una nueva versión de archivos para las carpetas `static` y `templates`. Estos archivos se pueden descargar de este [Google Drive](https://drive.google.com/file/d/1zxpdynco01VJQmh8cO8YkkvWrDOijeRm/view?usp=sharing), lo debe descomprimir, y reemplazar las carpetas `static` y `templates` de su aplicación `tienda_virtual`.\n",
        "\n",
        "Ejecute en el servidor (`python manage.py runserver`), vaya al navegador y abra su sitio web (`http://127.0.0.1:8000/tienda_virtual/`), y todo está terminado. Felicitaciones, ha logrado tener una primera versión funcional usando `Django` y `MongoDB` de una Tienda Virtual.\n",
        "\n",
        "\n",
        "# Errores Detectados\n",
        "### PIP no es reconocido como comando\n",
        "En este caso, solo requiere instalar de manera específica. Para ello, ejecute las siguientes instrucciones:\n",
        "```\n",
        "curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py\n",
        "python get-pip.py\n",
        "```\n",
        "Una vez esto se ejecute por completo, pruebe de nuevo el comando _pip_.\n",
        "\n",
        "\n",
        "### Windows no permite la ejecución de Scripts: \n",
        "En este caso, vaya al buscador en Windows (lupa en la parte inferior izquierda), y escriba _Powershell_, allí verá una opción de `Abrir como Administrador`, de click en ella y coloque la siguiente instrucción:\n",
        "```\n",
        "Set-ExecutionPolicy RemoteSigned\n",
        "```\n",
        "Haga enter, y vuelva y pruebe la activación del entorno virtual, deberá funcionar de manera normal.\n",
        "\n",
        "### Error en el PATH de Python en Windows\n",
        "Error típido. Lo puede resolver agregando el path manualmente, o reinstalando `python` como se muestra en [aquí]{https://www.mclibre.org/consultar/python/otros/python-instalacion.html}.\n",
        "\n",
        "## Error ejecutando PyMongo\n",
        "Si al intentar ejecutar `PyMongo` se lanza el siguiente error:\n",
        "```\n",
        "pymongo.errors.BulkWriteError: batch op errors occurred, full error: {'writeErrors': [{'index': 0, 'code': 13297, 'errmsg': 'db already exists with different case already have: [tiendavirtual] trying to create [tiendaVirtual]', 'op':\n",
        "```\n",
        "Es un tema de conflictos de IDs en la base de datos creada de `tiendaVirtual`. Se recomienda eliminar la base de datos `tiendaVirtual`, y trabajar con una base de datos nueva, o una base de datos con otro nombre."
      ]
    }
  ]
}