Wiki

Clone wiki

Django Plug Modules / creando

Creando módulos con dependencias

Para el manejo de los distintos módulos cada uno contará con un fichero .yaml llamado config.yaml, este fichero tendrá toda la información acerca del módulo que pertenece y a su vez se podrá definir dependencias hacia otros módulos necesarios.

La estructura del fichero config.yaml contrendra lo siguiente:

module:                                           #module: No se modifica.
    name: personal                                #name: nombre del módulo.
    title: personal                               #title: titulo del módulo.
    description: personal de la institución       #description: descripción corta del módulo.
    ver: !!str 0.0.1                              #ver: !!str string numérico compuesto por 3 números separados por un punto, se refiere a la versión del módulo.
    icon: personal.png                            #icon: nombre de una imagen de, la ruta donde debe ir la imagen debe ser <nombre_modulo>/media/.
    url: /personal/                               #url: es la url madre que será asignada a este módulo.
    depends:                                      #depends: no se modifica.
        hard:                                     #hard: contiene las dependencias fuertes.
            - base>=0.0.1                             # dependencia compuesta de tres partes(nombre|operador|versión), base se refiere a la versión de módulo al cual depende, operador se refiere al operador y versión a la versión de módulo del cual depende.
        soft:                                     #soft: dependencias débiles del módulo. 

La configuración de los módulos es simple, nos concentraremos en detallar los dos tipos de dependencias que se pueden manejar:

  • Dependencias fuertes (hard:).
  • Dependencias débiles (soft:).

Para definir una dependencia ya sea fuerte ó débil, basta con colocar el nombre del módulo del cual depende el que estamos trabajando, con la siguiente estructura.

Supongamos que nuestro módulo contabilidad depende fuertemente de un módulo llamado base de la versión 1.0.0. , definiriamos dicha dependencia de la siguiente forma

  • La dependencia debe ir bajo la etiqueta: (hard:)
hard:
  • El nombre de pendencia debe ir antecedido por un guión (-) seguido de un espacio en blanco.
hard:
    - 
  • Nombre, es el nombré del módulo del que depende, en nuestro caso depende del módulo base.
hard:
    - base
  • Operador, es el operador que utilizaremos para limitar el número de versión de la dependencia, se puede utilizar tres tipos de operadores; (==) para delimitar a igual, (<=) para delimitar a un número menor ó igual, (>=) para delimitar un número mayor ó igual. En nuestro caso definiremos que el módulo al cual depende debe ser igual (==).
hard:
    - base==
  • Versión, es el número de versión del módulo dependiente al cual se le aplica el operador (==), en nuestro caso es 1.0.0
hard:
    - base==1.0.0

En la medida en que el módulo necesite mas dependencias , las mismas deben ser agregadas en una nueva líneas dependiendo si es fuerte ó debil.

Diferencias entre dependencias fuertes y débiles

La principal diferencia entre ambas es la flexibilidad.

Fuertes

Las dependencias fuertes como su nombre lo indica son dependencias que deben cumplirse estrictamente para que el sistema y/o módulo puede funcionar. Si se define una dependencia fuerte el cual no es cumplida ó el modulo al que esta se refiere no existe, el sistema dará un mensaje de excepción que no permite funcionar al sistema.

Supongamos que en el módulo de ejemplo anterior contabilidad ya he configurado el fichero config.yaml con una dependencia al módulo base. El fichero luciría así:

module:
    name: contabilidad
    title: contabilidad
    description: contabilidad
    ver: !!str 0.0.1
    icon: none.png
    url:
    depends:
        hard:
            - base==1.0.0
        soft:

Al ejecutar el proyecto.

$ python manage.py runserver

Obtendremos el siguiente error, ya que no se cumple la dependencia.

Exception: Core App Error:
Dependencia no satisfecha
M?dulo contabilidad depende del m?dulo (base==1.0.0)

Eception: Core App Error

Como conclusión entonces podemos decir que si no se cumple una dependencia fuerte en la totalidad de los módulo, el sistema o proyecto no podrá ser ejecutado.

Débiles

Las dependencias débiles son las mas complejas ya que el no cumplimiento de las dependencias de este tipo en un módulo, no limita la ejecución del sistema o proyecto.

Ejecutemos el comando para la creación de de un nuevo módulo, crearemos el módulo con dependencia fuerte base versión 1.0.0.

$ python manage.py startmodule base

Editamos el fichero modules/base/config.yaml y colocamos la versión 1.0.0, debe quedar así:

module:
    name: base
    title: base
    description: base
    ver: !!str 1.0.0
    icon: none.png
    url:
    depends:
        hard:
        soft:

Ejecutamos el proyecto. $ python manage.py runserver

Luego entramos con el Browser a la dirección de información de módulos http://localhost:8000/django_plug_modules/info/

Obtendremos la siguiente vista con información de los módulos.

info

Ya se puede apreciar como empieza a aparecer más información acerca de los módulos y la relación existente entre ellos.

Es el momento de empezar con las dependencias débiles, supongamos que nuestro módulo contabilidad tiene una dependencia débil con un módulo llamado bancos en su versión 1.1.1. Editamos el fichero modules/contabilidad/config.yaml y agregamos la dependencia, quedará así.

module:
    name: contabilidad
    title: contabilidad
    description: contabilidad
    ver: !!str 0.0.1
    icon: none.png
    url:
    depends:
        hard:
            - base==1.0.0
        soft:
            - bancos==1.1.1

Ejecutamos el sistema o proyecto $ python manage.py runserver

Y observamos que a diferencia que cuando ejecutamos el sistema con una dependencia fuerte que no existía, nuestro sistema funciona pese a no cumplir con la dependencia débil bancos==1.1.1, una vista en la url de información de los móduloshttp://localhost:8000/django_plug_modules/info///.

info

Las fechas del gráfico nos brindan información útil:

  • La dirección: estable el origen de la dependencia.
  • El color: el verde indica si se cumple con la dependencia y el rojo si no se cumple.
  • El estilo: de línea solida indica que es una dependencia fuerte, de línea punteada indica que es una dependencia débil.

Trabajando dependencias con las débiles

django-plug-modules provee una clase útil que permite obtener información de los módulos y conocer si se cumplen ó no las dependencias débiles para habilitar ó no opciones dentro de nuestro módulo.

A nivel de desarrollo todo se centra en saber si existe una dependencia débil, para que determinado módulo ejecute ciertas instrucciones, si no existe una dependencia el módulo trabajar de forma diferente.

Ya hemos establecido en el fichero de configuración del módulo contabilidad una dependencia débil con el modulo de bancos. Crearemos el módulo bancos con el comando:

$ python manage.py startmodule bancos

Supongamos que el módulo de bancos tiene una tabla llamada Bancos con tres campos; nombre, direccion.

El fichero modules/bancos/models.py debe tener lo siguiente:

# -*- coding: utf-8 -*-
from django.db import models
     
#from django_plug_modules.modules import AppConf
#conf = AppConf()

class Bancos(models.Model):
    nombre = models.CharField(max_length=100)
    direccion = models.CharField(max_length=300)

Podemos sincronizar la base de datos y veremos como se crea la tabla bancos_bancos.

syncdb

Ahora trabajaremos con la dependencia desde el módulo contabilidad, el cual definiremos una tabla llamada Asiento en el fichero modules/contabilidad/models.py que contendrá tres campos, el primero sera codigo, el segundo sera nombre y el tercero es el que preguntara si se cumple la dependencia débil con bancos para crear un campo llamado bancos que sera una clave foránea al módulo de bancos a la tabla Bancos.

# -*- coding: utf-8 -*-
from django.db import models
     
from django_plug_modules.modules import AppConf
conf = AppConf()

if conf.soft_check_depends('contabilidad', 'bancos'):
    from bancos.models import Bancos

class Asiento(models.Model):
    codigo = models.CharField(max_length=100)
    nombre = models.CharField(max_length=100)
    
    if conf.soft_check_depends('contabilidad', 'bancos'):
        banco = models.ForeignKey(Bancos)

Paso a explicar por líneas:

4 from django_plug_modules.modules import AppConf, se importa la clase AppConf.

5 conf = AppConf(), se instancia la clase.

7 if conf.soft_check_depends('contabilidad', 'bancos'):, se utiliza la función soft_check_depends(<nombre módulo>, <nombre módulo>), donde el primer parámetro es el nombre del módulo que queremos conocer si cumple con la dependencia y el segundo parámetro es el nombre del módulo con el cual depende.

8 from bancos.models import Bancos, si se cumple la dependencia importa la clase modelo Bancos.

14 if conf.soft_check_depends('contabilidad', 'bancos'):, nuevamente se pregunta si se cumple la dependencia.

15 banco = models.ForeignKey(Bancos), si la dependencia existe se crea una clave foránea a la tabla de Bancos.

Este es el modo de trabajar con las dependencias débiles, en cualquier entorno de python de su proyecto usted puede utilizar la clase django_plug_modules.modules.AppConf en formularios (forms.py), vistas (views.py), *.py, para filtrar qué operaciones realizar cuando existen o no las dependencias débiles.

El otro ámbito donde es necesario conocer si se cumplen las dependencias es en los templates (html), para eso basta con utilizar la etiqueta {% load modules %} y se pregunta por las dependencias con la instrucción {% AppConf_soft_check_depends "<nombre módulo>,<nombre módulo>"%}.

Un ejemplo de como filtrar las dependencias en un template podría ser:

modules/contabilidad/views.py

# -*- coding: utf-8 -*-
from django.http import HttpResponse
from django.shortcuts import render_to_response

def hola(request):
    return HttpResponse('Hola Mundo! - Módulo de Contabilidad')
    
def asiento(request):
    return render_to_response('contabilidad_asiento.html')

modules/contabilidad/templates/contabilidad_asiento.html

{% load modules %}

<h1>Asiento Contable</h1>

Código: x

Nombre: y

{% AppConf_soft_check_depends "contabilidad,bancos" %}

{% if contabilidad_bancos %}
    <h2>banco: si existe</h2>
{% endif %}

modules/contabilidad/urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
                      (r'hola_mundo/$', 'contabilidad.views.hola'),
                      (r'asiento/$', 'contabilidad.views.asiento'),
                      )

Ejecutando en el Browser http://localhost:8000/contabilidad/asiento/

template

Updated