Como Empezar
Creando el primer paquete Plasta
Estructura de un ABM
Cada ABM se conforma por un paquete Python, que contiene la siguiente estructura:
Clase Objeto (Ejemplo: Cliente).
Clase Controladora (Ejemplo: ClientesManager)
Clase Main del ABM (Ejemplo: ClientesGUI)
Clase para dar de alta un registro (Ejemplo: AddCliente)
* Archivo .ui de Qt para la pantalla del
El paquete resultante entonces quedaría algo así:
/cliente
|--- __init__.py
|--- manager.py
|--- gui.py
|--- add.py
|--- add.ui
A continuación se detalla como se componen cada uno de los archivos del paquete:
1. Creando el archivo __init__.py
Continuando con el ejemplo de “Cliente”, lo primero que haremos es crear un paquete Python para el objeto Cliente: creamos la carpeta /cliente
y dentro de ella, creamos el archivo __init__.py
.
El código para el archivo sería algo así:
from storm.locals import *
class Cliente (object):
# nombre que tendrá la tabla en la BD para este objeto
__storm_table__ = "cliente"
# atributos de la clase
id = Int(primary = True)
nombres = Unicode(allow_none = False)
telefono = Unicode()
domicilio = Unicode()
zona = Int()
def __init__(self, nombres, telefono, domicilio, zona):
self.nombres = nombres
self.telefono = telefono
self.domicilio = domicilio
self.zona = zona
# valor que se mostrará al invocar esta función
def __str__(self):
return self.nombres
Al estar usando Storm como ORM, Plasta se ajustará a cómo esta tecnología se comporte.
2. Creando el archivo manager.py
Una vez hecho el objeto Cliente, pasamos a crear la clase controladora para este objeto.
Por convención usaremos el nombre ClientesManager
. Quedando algo
así:
from plasta.logic.manager import BaseManager
from cliente import Cliente
class ClientesManager( BaseManager ):
def __init__( self, store, reset = False ):
BaseManager.__init__( self, store, reset )
# objeto a ser manejado por este controlador
self.CLASS = Cliente
self._start_operations()
Esta sería la estructura base de una clase manager. Lo único que cambiaría para cada caso es: el nombre de la clase y el objeto que controla (self.CLASS).
Hasta aquí tenemos listas las dos clases de la “lógica” que se necesitan para poder realizar las operaciones de agregar, editar, eliminar y buscar.
Ahora veremos cómo conectamos esto con la interfaz gráfica.
3. Creando el archivo gui.py
Creamos el archivo gui.py y renombramos la clase a “ClientesGUI”:
from plasta.gui import BaseGUI
from cliente import Cliente
from cliente.add import AddCliente
class ClientesGUI(BaseGUI):
def __init__(self, manager, managers = []):
# llama al costructor de la clase base
BaseGUI.__init__(self, manager, managers)
# clase que mostrará a los diálogos de agregar y editar
self.DialogAddClass = AddCliente
self.loadUI()
# atributos usados como filtros
self.addFilter(u'Nombres', Cliente.nombres)
self.addFilter(u'Telefono', Cliente.telefono)
self.addFilter(u'Dirección', Cliente.direccion)
self.addFilter(u'Zona', Cliente.zona)
# columnas/atributos mostrados en la lista
self.addTableColumn(u'#', Cliente.id, alignment='C')
self.addTableColumn(u'Nombres', Cliente.nombres)
self.addTableColumn(u'Telefono', Cliente.telefono)
self.addTableColumn(u'Dirección', Cliente.direccion)
self.addTableColumn(u'Zona', Cliente.zona, alignment='C')
# realiza las operaciones de inicio para levantar la ventana
self._start_operations()
4. Creando el archivo add.py
Por último crearemos el archivo add.py, y su contenido sería este:
from plasta.gui.add import BaseAdd
from cliente import Cliente
class AddCliente(BaseAdd):
def __init__(self, manager, itemToEdit = False, managers = []):
# constructor de la clase base
BaseAdd.__init__(self, manager, itemToEdit)
# lee y levanta la información del archivo ui
self.loadUI('cliente/add.ui')
# aquí indicaremos qué widget de la interfaz
# se corresponde con un atributo de la clase
self.linkToAttribute(self.leNombres, Cliente.nombres)
self.linkToAttribute(self.leTelefono, Cliente.telefono)
self.linkToAttribute(self.leDireccion, Cliente.direccion)
self.linkToAttribute(self.leZona, Cliente.zona)
self._start_operations()
Es importante destacar que con la funcion self.linkToAttribute
indicaremos con qué widget se corresponderá que atributo de la clase que estamos manejando.
Para que cuando se de alta un registro, el valor contenido en ese widget, se establezca en ese atributo del objeto.
Es necesario que el orden en que estén indicados los items, se corresponda con el orden de los parámetros en el constructor de la clase del objeto con el que se este trabajando.
Usando el generador de Plasta para crear este paquete, el comando sería el siguiente:
$ python plastagen plastagen g crud cliente nombres telefono domicilio zona
5. Creando el archivo run.py
Por último crearemos el archivo que ejecutará la aplicación:
import sys
from PyQt4 import QtGui
from storm.locals import create_database, Store
from cliente.manager import ClientesManager
from cliente.gui import ClientesGUI
# objeto Store de Storm
DATABASE = create_database('sqlite:prueba.db')
store = Store(DATABASE)
# instancia del manager de ClientesGUI
cm = ClientesManager(store, reset = True)
# mostrando la ventana
app = QtGui.QApplication(sys.argv)
window = ClientesGUI( manager = cm, managers = [] )
window.show()
sys.exit(app.exec_())
Ir a > Inicio | Ir a > Instalación | Ir a > Como empezar | Ir a > Casos de uso | Ir a > Aplicaciones de ejemplo