lunes, 11 de marzo de 2013

Plugin modal -> Bootstrap -> WEB2PY

A continuación el código del Plugins, el modo de uso y unas capturas de pantalla.

# Colocar el siguiente código en un archivo de texto plano. (modalplugins.py)

#-*- encoding:utf-8 -*- # * formModal
from gluon.html import A, DIV, H3, BUTTON, OPTION, TAG, I, XML
from gluon.sqlhtml import SQLFORM
from gluon.compileapp import LOAD
from gluon.http import HTTP
from gluon import current
class Modal(object):
     def __init__(self, field, value, title_btn, title_modal):
         self.field = field
         self.value = value
         self.title_btn = title_btn
         self.title_modal = title_modal
         self.key = str(self.field).replace('.', '_')
         self.modal_id = 'modal_%s' % self.key
         self._target = "c_" + self.key
         self.request = current.request
         self.response = current.response
         self.session = current.session

     def btn_show(self):
         # Button to trigger modal .
        btn_show_modal = A(I(_class="icon-plus-sign"),
                             ' ', self.value,
                             **{"_role": "button",
                                #"_class": "btn btn-link",
                               "_data-toggle": "modal",
                                "_href": "#%s" % self.modal_id,
                                "_title": self.title_btn})
         return btn_show_modal

     def div_modal(self, content_modal):

         div_modal = DIV(
                         DIV(
                             H3(self.title_modal, _id="myModalLabel"),
                             _class="modal-header"),
                         DIV(content_modal, _class="modal-body"),
                         DIV(
                             BUTTON("Cerrar", **{"_class": "btn",
                                                 "_data-dismiss": "modal",
                                                 "_aria-hidden": "true"}),
                             _class="modal-footer",
                             ),
                         **{"_id": "%s" % self.modal_id,
                            "_class": "modal hide face",
                            "_tabindex": "-1",
                            "_role": "dialog",
                            "_aria-hidden": "true",
                            "_aria-labelledby": "myModalLabel"}
                     )
         return div_modal

     def create(self):

         if not self.field.type.startswith('reference'):
             raise SyntaxError("Sólo puede usarse con field reference")
         if not hasattr(self.field.requires, 'options'):
             raise SyntaxError("No puede determinarse las opciones")
         if self.request.get_vars._ajax_add == str(self.field):
             table = self.field._db[self.field.type[10:]]
             raise HTTP(200, self.checkForm(table))
         return self.btn_show()

     def formModal(self):

         return self.div_modal(LOAD(self.request.controller,
                                     self.request.function,
                                     args=self.request.args,
                                     vars=dict(_ajax_add=self.field),
                                     target=self._target,
                                     ajax=True)
                                 )

     def checkForm(self, table):
         formnamemodal = "formmodal_%s" % self.key
         form = SQLFORM(table, formname=formnamemodal)
         if form.accepts(self.request.vars,
                         self.session,
                         formname=formnamemodal):
             options = TAG[''](*[OPTION(v,
                             _value=k,
                             _selected=str(form.vars.id) == str(k))
                             for (k, v) in self.field.requires.options()])
             _cmd = "jQuery('#%s').html('%s');"
            _cmd += "jQuery('#%s').modal('hide')"
            command = _cmd % (self.key,
                               options.xml().replace("'", "\'"),
                               self.modal_id
                              )
             self.response.flash = 'Se creó el registro'
            self.response.js = command
         elif form.errors:
             self.response.flash = "Controle el formulario"

        return form


  Modo de uso (Ejemplo)

# Creamos dos modelos en el archivo db.py sobre el directorio models de la application.

db.define_table('area',
     Field('nombre'),
     Field('descripcion'),
     format='%(nombre)s')

db.define_table('docente',
     Field('nombre'),
     Field('dni'),
     Field('id_area', db.area),
     format='%(nombre)s')

# Modificamos el controller/default.py ->

def index():
     from modalplugins import Modal
     field = db.docente.id_area
     modal = Modal(field, 'Add', 'Add area', 'Área')
     db.docente.id_area.comment = modal.create()

     form = SQLFORM(db.docente)
     if form.accepts(request.vars, session):
         response.flash = "Se creó el registro"
    elif form.errors:
         response.flash = "Controle el formulario"
    return dict(form=form, formmodal=modal.formModal())

# Modificamos la view/index.html

{{extend 'layout.html'}}

<h3> Formulario Docente </h3>
{{=form}}
{{=formmodal}}


# Les adjunto unas imágenes con los resultados del modal.





jueves, 24 de enero de 2013

MS Access desde Ubuntu con Python and Web2py

Tiempo al tiempo.

Hace unos días estoy trabajando en un sistema desarrollado en MS Access en el cual tengo que hacer una interfaz de consultas a la base de datos.
A la interfaz la estoy desarrollando con Web2py, framework que hasta el día de hoy me trajo mucha satisfacción.

¿Cómo abrimos una DB MS Access desde python?

La solución a esta pregunta la tiene el módulo pyodbc.
Desde la página pueden descargar el ejecutable para windows. Deben descargar el ejecutable dependiendo de su versión de Python que tengas instalado, o si están en un sistema de la familia Debian pueden utilizar apt. (sudo apt-get install python-pyodbc)
Para realizar la conexión en Windows necesitan una cadena de conexión (valga la redundancia) que la pueden obtener desde aquí:
  • http://code.google.com/p/pyodbc/wiki/ConnectionStrings

Conexión en Windows.

>>> import pyodbc
>>> cadena_conexion = 'Driver={Microsoft Access Driver (*.mdb, *.accdb)}; Dbq=C:\Users\Martin\Desktop\CPCE\cpcec.mdb;UID=user;PWD=password'
>>> c = pyodbc.connect(cadena_conexion)
>>> csr = c.cursor()
>>> csr.execute("select * from tablename")
>>> row = csr.fetchone()
>>> print row

Conexión en GNU/Linux Ubuntu

Para conectar una DB MS Access en Ubuntu necesitamos un set de herramientas.
Las instalaciones desde la línea de comandos son las siguientes:
  • sudo apt-get install mdbtools
  • sudo apt-get install libmdbodbc1
  • sudo apt-get install python-pyodbc
Una vez instaladas las herramientas procedemos a una pequeña configuración, para ello necesitamos editar un par de archivos.
  •  sudo nano /etc/odbcinst.ini
    [MDBTools]
    Description = MDBTools Driver
    Driver = libmdbodbc.so.1
    Setup = libmdbcodbc.so.1
    FileUsage = 1
    UsageCount = 1
     
  •  sudo nano /etc/odbc.ini
    [MiConexion]
    Description = Microsoft Access Try DB
    Driver = MDBTools
    Database = /path/database.mdb
    Servername = localhost
    Username = User
    Password = Password
Una vez configurado el archivo de conexión ingresamos a un interprete de Python y chequeamos.

>>> import pyodbc
>>> c = pyodbc.connect('DSN=MiConexion')
>>> csr = c.cursor()
>>> csr.execute(" select * from tablename")
>>> row = csr.fetchone()
>>> print row

Conexión con la DAL desde Web2py en GNU/Linux.

Debemos seguir los pasos de configuración mencionados anteriormente, luego ingresamos al archivo db.py en el directorio models de nuestra aplicación y en la instanciación de la DAL agredamos la cadena de conexión.

  • db = DAL('mssql://DSN=MiConexion')
Para hacer una prueba podemos hacer lo siguiente:

>>> python /path/web2py/web2py -M -S myapp
>>> db.executesql('select * from tablename')

Espero que les sirva, un abrazo.

Martín.

P/d: MS Access es una c*gada. :)