Implementación de varias clases que se comunican.
Primeramente se nota algo raro en el codigo pues es el sistema de plantillas django se explica en el siguiente
texto : El sistema de plantillas de Django
Te has fijado que el algunos programas el HTML estaba directamente dentro del código en Python!
Esta disposición de las cosas nos lleva a varios problemas:
Obviamente, cualquier cambio en el diseño de la página conllevará un cambio del código. El diseño de
un sitio tiende a cambiar mucho más rápidamente que el código subyacente, así que sería
conveniente si los cambios del HTML estuvieran separados de los cambios del código.
• Segundo, escribir código de backend en Python y diseñar/escribir HTML son dos disciplinas diferentes,
y la mayoría de los entornos profesionales de desarrollo Web dividen estas responsabilidades entre
personas distintas (o inclusos departamentos distintos). Los diseñadores y programadores de
HTML/CSS no deberían tener que editar código en Python para hacer su trabajo; sólo deberían tratar
con HTML.
• Asimismo, es más eficiente que los programadores puedan trabajar en su código en Python y los
diseñadores en sus plantillas de forma simultánea, en lugar de que una persona tenga que esperar
que la otra acabe de editar un único fichero que contiene tanto Python como HTML.
•
Por estas razones, es mucho más limpio y mantenible separar el diseño de la página del propio código en
Python. Y podemos conseguirlo con el sistema de plantillas de Django.
Introducción al sistema de plantillas
Una plantilla de Django es una cadena de texto pensada para separar la presentación de un documento de
sus datos. Una plantilla define variables y varios trozos de lógica básica (tags) que regulan la manera en que
debería mostrarse el documento. Normalmente, las plantillas se usan para producir HTML, pero las plantillas
de Django son igualmente capaces de generar cualquier formato basado en texto.
Fuente : http://the-geek.org/django-book/chapter4/
class
Menu(webapp.RequestHandler):
def get(self):
template_values = {}
path=os.path.join(os.path.dirname(__file__),'index.html')
self.response.out.write(template.render(path,template_values))
class Formulario(search.SearchableModel):
nombre= db.StringProperty()
apellido = db.StringProperty()
class
Index(webapp.RequestHandler):
def get(self):
template_values = {}
path = os.path.join(os.path.dirname(__file__), 'registro.html')
self.response.out.write(template.render(path, template_values))
class
datosprincipales(webapp.RequestHandler):
def post(self):
template_values = {
'txtedad': self.request.get('txtedad'),
'txtApellidos': self.request.get('txtApellidos').upper(),
*Faltan mas por agregar
}
path = os.path.join(os.path.dirname(__file__), 'datos.html')
self.response.out.write(template.render(path, template_values))
class
guardar(webapp.RequestHandler):
def post(self):
formulario = Formulario()
template_values = {
'txtApellidos': self.request.get('txtApellidos').upper(),
'txtNombres': self.request.get('txtNombres').upper(),
'txtCorreo': self.request.get('txtCorreo').lower(),
'tieneCorreo': (formulario.correo != '')
}
path = os.path.join(os.path.dirname(__file__), 'mensaje.html')
self.response.out.write(template.render(path, template_values))
class buscar(webapp.RequestHandler):
def get(self):
txtFullText = self.request.get('txtFullText').upper()
if txtFullText <> '':
formularios = Formulario.all().search(txtFullText)
template_values = {
'formularios': formularios
}
else:
template_values = {}
path = os.path.join(os.path.dirname(__file__), 'busqueda.html')
self.response.out.write(template.render(path
Fragilidad. Muy relacionada con la rigidez está la fragilidad. La fragilidad es la tendencia que tiene el software a romperse por muchos sitios cada vez que se cambia algo. Muchas de las roturas ocurren en sitios que no están relacionados conceptualmente con el área que se está cambiando. Cada vez que los gestores autorizan un cambio tienen miedo de que el programa se rompa por algún lugar inesperado.
