pyMFrame

Ein WEB Framework in Python

Autor: W.Nagy

Creative Commons Attribution-ShareAlike 2.0 license

Navigieren in dieser Präsentation durch Pfeiltasten
↑ vorherige Seite, ↓ Folgeseite.

Diese Präsentation ist erstellt mit S5

Restriktion

Dieses Dokument enthält Rechtschreibfehler.
Der Finder darf diese zu privaten Zwecken vervielfältigen, verändern oder sonst wie gebrauchen.
Der Autor behält aber dabei alle Rechte. Eine kommerzielle Verwendung bedarf der ausdrücklichen schriftlichen Zustimmung des Autors.

Sollte trotz sorgfältiger Bearbeitung keine Rechtschreibfehler enthalten sein,
so bitten der Autor um schriftliche Verständigung (microframework@gmail.com), dieser wird ehebaldigst einen korrekten Zustand wieder herstellen.

Meine Motivation das Framework zu entwicklen

Ich wollte Python lernen
Ich schreibe gerne Frameworks
Ich wollte gerne ein auf meine persönlichen Bedürfnisse angepasstes System haben
Ich habe schnell ein System gebraucht, welches eine kurze Lebensdauer hatte
Es macht Spass :-)

Hintergrund

pyMFrame ist ein Webframework in der Sprache Python.
Das original mFrame

wurde in groovy entwickelt.
pyMFrame ist eine Portierung des Originals in Python.
Es wurden ca. 70% des Funktionsumfangs portiert.

Kenndaten

Menü
Kennwortschutz
Rechte/Rollen
Templates
MVC Modell
Taglib
Optionale Datenbankanbindung
derzeitig sqlite3
Viewer mit eingebetten Pythoncode
Typensichere Domains

Hintergrund - 2

Das Framework ist nicht als Konkurenz zu bestehenden Frameworks gedacht.

Warum nicht Django, etc.

Das Framework dient hauptsächlich zu Test und Schulungszwecken.

Einfache Änderungen im Kode
Klein und Übersichtlich
Großteils unabhängige Klassen

Einsatz als/für...

Kleinprojekte
Websites welche Passwortschutz aber keine aktiven Inhalte haben
Kodebaukasten
Rapid Prototyping

Architektur

Verzeichnisstruktur

Das Framework setzt eine Verzeichnisstruktur voraus.

\---application                        Applikationsroot
    +---applib                         
    |   +---datastore                  Datenbank,sonstiges
    |   |   +---database               Datenbankverzeichnis
    |   |   \---sideboxes              Sideboxes Texte
    |   +---mframe                     Framework Klassen
    |   |   \---_test                  Unit-Tests
    |   +---session                    Sessionsdateien
    |   \---WEB-INF                    Anwendungsdateien
    |       +---conf                   Konfigurationsdateien
    |       +---mvc                    Einsprungspunkt vom MVC
    |       |   +---authen             Authentifizierungsroutine
    |       |   +---domain             Domains
    |       |   \---root               Controller und Viewer
    |       |       +---examples       Beispiele
    |       |       |   +---event
    |       |       |   +---list
    |       |       |   +---lov
    |       |       |   \---mask
    |       |       +---extras         Weitere Beispiele
    |       |       |   +---lov
    |       |       |   \---sideboxedit
    |       |       \---hintergrund
    |       \---templates             Templates
    \---www                           URL erreichbare Dateien
        +---css                       
        |   \---skin
        |       \---normal
        +---images
        |   \---skin
        |       \---normal
        +---info
        |   \---dokumente
        \---scripts                   Hier ist start.py

Diese Verzeichnisstuktur kann durch Anpassungen in der Konfiguration geändert werden.

Konfiguration

Im Skript start.py werden die Pfade auf die Bibliotheken gesetzt.
In der Klasse applib/WEB-INF/conf/config.py könnnen die Pfade auf die Verzeichnisse welche nicht über ein URL erreichbar sein sollen verändert werden.

#! /usr/bin/python
# ### Rootverzeichnis setzen
# Diese Seqünz ist nur notwendig,
# wenn der Python interne Webserver (CGIHTTPServer) verwendet wird.
# HINT:
#   wird Apache verwendet wird der rootpath
#   automatisch auf das Verzeichnis gesetzt,
#   in welchem dieses Skript residiert.
#
if os.environ['SERVER_SOFTWARE'].find('SimpleHTTP') != -1:
   cwd = os.getcwd()

   if os.name == 'posix': # wir sind auf dem Max (OSX)
      os.chdir('<path in OSX (Mac)>')
   elif os.name == 'nt': # windows
      path =cwd+'/scripts'
      os.chdir(path)

# ### Definition der Pfade auf Bibliothken 
# Definiere Path auf Framework
sys.path.extend(['../../applib/mframe'])

# ### Hilfs Klassen
sys.path.extend(['../../applib/WEB-INF'])

# Definiere Root für Controller
sys.path.extend(['../../applib/WEB-INF/mvc'])

Benutzerverwaltung

Die Benutzerwerwaltung wird in der Klasse applib/WEB-INF/conf/authen.py geregelt. Für jeden Benutzer muss ein Dictionary eingerichtet werden.

 Beispiel:
    userlist = [
      {  'user'         : 'admin',
         'password'     : 'admin',
         'rights'       : ['admin']
         },
      {  'user'         : 'default',
         'password'     : '',
         'rights'       : ['default']
         },
      ]

Dies ist nur ein Beispiel. Die Benutzerverwaltung kann genausogut aus der einer Datenbank oder mit anderen Methoden erfolgen.

Menü - Allgemein

Die Menüeinträge werden in der Klasse applib/WEB-INF/conf/menu.py deklariert. Die Menüs werden mittels des path Eintrages gegliedert.
Beispiel

   entries=[
     {
        'path':'/root',
        'controller':'RootController',
        'text':'start'
     },
     {
        'path':'/root/hintergrund',
        'controller':'HintergrundInfoController',
        'text':'hintergrund'
     },
     {
        'path':'/root/informationen/gruppen/showgruppe',
        'controller':'ShowGruppeController',
        'rights':['admin','gruppe']
     },
     
...

Das Framwork stellt die Navigation zur Verfügung. Es werden die Einsprungsliste und die Backling Liste zu Verfügung gestellt.

Menü - Rechte

Rechte

Jedem Menüeintrag kann ein oderer Mehrer Rechte zugeteilt werden.
Wird der Eintrag rights leer gelassen, so kann der Controller von jedem genutzt werden.
Die Rechte werden als Liste eingetragen.
Beispiel:

     {
        'path':'/root/informationen/gruppen/showgruppe',
        'controller':'ShowGruppeController',
        'rights':['admin','gruppe']
     },

Dieser Menüeintrag wird nur angezeigt bzw. aktiviert, wenn der Benutzer das Recht 'admin' oder 'gruppe' zugewiesen bekommen hat (Siehe Benutzerverwaltung).

Controller

Ein Controller ist im wesentlichen ein Pythonskript welches vom Framework ausgeführt wird.
Hallo Welt Beispiel:

   from controller import Controller

   class RootController(Controller):

      def get(self):
         return 'Hallo Welt.'

Die Anweisug 'render'.

Um in den HTML Buffer zu schreiben kann die Methode self.render verwendet werden.

self.render("Hallo Welt.")

Der Buffer self.html

Die Ausgaben werden im Buffer self.html gesammelt. return self.html

Viewer

Der Viewer wird als eigenständige Datei im selben Verzeichnis wie der Controller gehalten.
Er ist im wesentlichen ein HTML Schnippsel.

Viewer sind eine Templatemaschine. Er kann auch Nutzcode enthalten. Aufruf eines Viewers aus dem Controller.
Beispiel:

 self.view('view.tpl')

Viewer - Details

Der Viewer aktzeptiert drei Parameter.

Viewer-Filename
param optional ein Dictionary von Bindingparametern
importcgi (True/False) optional
True: es werden alle Parameter aus dem CGI in die Bindingsvariable übernommen.

self.view('list.tpl',
      {
      'netto':123.4,
      }
   )

Beispiel eines Viewer:

<%
import time
%>
<h1>Test-Viewer</h1>
Datum <%out(time.strftime('%d.%m.%Y'))%>
Brutto <%out(netto * 1.2)%>

Domain - Hintergrund

Eine Domain ist ein Objekt, welches den Inhalt eines Datensatzes hält.
Meist wird damit der Inhalt einer Datenbanktabelle abgebildet. Dies muss aber nicht in allen Fällen so sein.

Wesentliche Methoden der Domain

Die Domain bietet die grundlegenden Funktionen

lesen eines Datensatzes über seinen Primary Key oder ein beliebige where Klausel
Iteration von Datensätzen (eachDomain) Mit der Möglichkeit einen Filter einzusetzen und das Sortierkriterium anzugeben
Einfügen eines Datensatzes (insert)
änderung eines Datensatzes (update)
Löschen eines Datensatzes (delete)
SQL Aggregatfunktionen (min, max, avg, sum, count)
Domains können typensicher gemacht werden

Die Domain kann dazu verwendet werden, Datensatzspezifische Funktionen als Methode zu halten. z.B. ORM. Stichwort Datenkapselung.
⇒Beispiele

Domain - Zugriff auf Daten

Datensatz über PK:

lov.get(1)

Datensatz mit where:

lov.get(where='lovValue = "eins" ')

Agregatfunktion mit where:

x = lov.count(where='lovValue = "eins" ')

Itteration über Datensätze

for l in lov.eachDomain():
   print l.lovName

Itteration über Datensätze mit where

cnt = 0
for l in lov.eachDomain(where='lovKey=1'):
   cnt+=1
assert(cnt==1)

Löschen des aktullen Datensatzes

lov.get(2)
lov.delete()

uvam.
⇒Beispiel Domain

Domain-Klasse Beispiel

Die Domain ist im wesentlichen eine Klasse welche als Attribute die Datenbankfelder und eine Datenstruktur mit Metadaten (meta) enthält.

# -*- coding: iso-8859-15 -*-
from dbaccess   import *

class EventDomain(Domain) :

   evtID                 = None
   evtName               = None
   evtBeginn             = None
   evtEnde               = None
   evtVeranstalter       = None
   evtOrt                = None
   evtPromot             = None
   evtPublic             = None
   evtBeschreibung       = None


   meta = {
      'tablename':'event',
      'primarykey':'evtID',
      
      'fields':{
         'evtID'           : {'dbfield':'evtID',            'type':'Integer'},
         'evtName'         : {'dbfield':'evtName',          'type':'String'},
         'evtBeginn'       : {'dbfield':'evtBeginn',        'type':'String'},
         'evtEnde'         : {'dbfield':'evtEnde',          'type':'String'},
         'evtVeranstalter' : {'dbfield':'evtVeranstalter',  'type':'String'},
         'evtOrt'          : {'dbfield':'evtOrt',           'type':'String'},
         'evtPromot'       : {'dbfield':'evtPromot',        'type':'String'},
         'evtPublic'       : {'dbfield':'evtPublic',        'type':'String'},
         'evtBeschreibung' : {'dbfield':'evtBeschreibung',  'type':'String'}
         }     

      }

⇒Typensicherheit

Typensichere Domains

Wenn gewüscht können Domain mit Typensicherheit versehen werden.
Der Datentyp eines Feldes wird in der Datenstruktur meta eingetragen:

'evtID' : {'dbfield':'evtID', 'type':'Integer'},

Typen:

Integer
String
Float
Date
EMail

Wird versucht einem Feld einer Domain ein Wert mit falschem Type zuzuweisen, wird eine Exception (ValueError) geworfen.

event.evtID = 'abc'
->  ValueError: evtID ist kein int ('abc')

Datum:
Als Datum können verschiedene Formate verwendet werden:

ANSI/ISO 2001-01-01
ANSI/ISO mit Zeit 2001-01-01T00:00 (optional mit Sekunde)
Deutsches Datum 1.1.2011
Deutsches Datum mit Zeit 01.01.2001 10:23 (optional mit Sekunde)

Im Domainfeld wird immer das Datum in ISO gespeichert.

Taglib

Die Klasse Taglib stellt verschiedene Methoden zur einfacheren Gestaltung von Webpages zu Verfügung. Diese Klasse wird jedem Viewer zu Verfügung gestellt.

Wesentliche Funktionen

promptinput
Diese Methode ist das Schweizer Taschenmesser für Eingabefelder.
form,endform
table, tablehead, tablerow
hidden
uvam.

Beispiel

      taglib.promptinput(
         name='lovClass',
         type='text',
         value=row[1],
         tr=False
         )
      )
out(taglib.promptinput(
   prompt='Auswahl',
   type='select',
   name="choose",
   value=cgiparam(name='choose',nvl='0'),
   datasource=[
      ['1','eins'],
      ['2','zwei'],
      ['3','drei'],
      ]
   )
 )

Templates

In den Templatedatein wird die HTML Seite mit Platzhalten beschrieben.
Es muss eine gültige HTML enthalten sein.
Es können beliebig viele Templates verwaltet werden. Im Controller kann man mit

self.main.setContainer([filename])

zwischen unterschiedlichen Templates umschalten.

Platzhalter

Platzhalter werden mit einem Dollarzeichen gekennzeichnet und koennen an beliebiger Stelle des Templates stehen.

  $stylesheet, $body, $menu, $flash, $backlink,  $sid, $user,  $sideboxes

<!-- DEFAULT TEMPLATE -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title> pyMframe::Ein Webframework in Python </title>
  <meta name="generator" content="mFrame" />
  <meta name="author" content="W.Nagy" />
  <meta name="keywords" content="Python Micro FramWork" />
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
$stylesheet
  
 </head>

 <body>
  <div class="site">
   <div class="header">
     pyMFrame
    <div style="display:inline;position:absolute;right:3px;top:3px;font-size:x-small;background-color:transparent;color:gray;">
    <a style="border:1px solid gray;background-color:transparent;font-size:smaller;color:gray;" href="start.py?path=/authen&action=logout">Abmelden</a> 
    </div>
   </div>
   <div style="position:absolute;
                top:3px;
                left:3px;
                background-color:transparent">
       <a href="http://nagy.zoff.cc/mframe" target="_blank" title="Zur Beschreibung des Frameworks"><img src="../images/mframe_logo_64x64.png" style="border:1px solid black;" alt="Logo mFrame"/></a>
   </div>
   <div class="backlink">
   $backlink
   </div>
   <div class="container">
    <div class="left">
     <b>Funktionen:</b><br />
     $menu
     ${sideboxes}
    </div>
    <div class="content">
     $flash
     $body
    </div>
   </div>
   <div class="footer">
      user: <b>$user</b> Version: $version mframe V:$mframeversion <div style="display:inline;position:absolute;right:3px;">© W. Nagy 2010</div>
   </div>
  </div>
 </body>
</html>

[*]

Kontakt

http://nagy.zoff.cc/pymframe

microframework@gmail.com

Geschafft...

Ende der Präsentation

MINI Handbuch


  .--------------------.
 /   README pymframe  /
'--------------------'

Datum: 10.2.2011
Autor: W. Nagy

INHALT
------
   - Hintergrund
   - Verzeichnisstruktur
   - Konfiguration
      - Benutzerverwaltung
      - Menu
      - Rechte
   - Controller
   - Viewer
   - Domain
   - Taglib
   - Templates

   UPDATE:
   2010-12-23  Beschreibung von Template
               Tops Bereinigung
   
HINTERGRUND
-----------
Die Anwendung kann über den python internen CGI Webserver CGIHTTPServer gestartet werden.
Windows:
cd <verzeichnis <approot>\www
python -m CGIHTTPServer

HINT:
   Das Skript CGIHTTPServer.py muss dahigehend veraendert werde, 
   dass der Server das Verzeichnis /script als Skriptverzeichnis erkennt.
   in oder in der Naehe der Zeile 95 muss die Anweisung auf
       cgi_directories = ['/cgi-bin', '/htbin', '/scripts']
   geaendert werden.

Aufrufurl: http://localhost:8000
username:   admin
passwort:   admin



VERZEICHNISSTUKTUR
------------------

 Es wird von folgender Verzeichnisstruktur ausgegangen 
\---application                        Applikationsroot
    +---applib                         Verzeichnis, welches nicht über ein URL erreichbar ist
    |   +---datastore                  Datenbank und sonstige Dateien
    |   |   +---database               Datenbankverzeichnis
    |   |   \---sideboxes              Sideboxes Texte
    |   +---mframe                     Framework Klassen
    |   |   \---_test                  Unit-Tests
    |   +---session                    Verzeichnis der Sessionsdateien (muss vom Server beschreibbar sein)
    |   \---WEB-INF                    Anwendungsdateien
    |       +---conf                   Konfigurationsdateien
    |       +---database
    |       +---mvc                    Einsprungspunkt vom MVC
    |       |   +---authen             Authentifizierungsroutine
    |       |   +---domain             Domains
    |       |   \---root               Controller und Viewer
    |       |       +---examples       Beispiele
    |       |       |   +---event
    |       |       |   +---list
    |       |       |   +---lov
    |       |       |   \---mask
    |       |       +---extras         Weitere Beispiele
    |       |       |   +---lov
    |       |       |   \---sideboxedit
    |       |       \---hintergrund
    |       \---templates             Templates
    \---www                           über das URL erreichbare Dateien. Verzeichnis auf das der Webserver zeigt.
        +---css                       
        |   \---skin
        |       \---normal
        +---images
        |   \---skin
        |       \---normal
        +---info
        |   \---dokumente
        \---scripts                   Hier ist start.py Einsprungspunkt der Anwendung
 


KONFIGURATION
-------------
 
 Im Skript start.py werden die Pfade auf die Bibliotheken gesetzt.
 
 In der Klasse applib/WEB-INF/conf/config.py
 koennnen die Pfade auf die Verzeichnisse welche nicht über ein URL erreichbar
 sein sollen veraendert werden.
 
Benutzerverwaltung
------------------
 Diese wird in der Klasse applib/WEB-INF/conf/authen.py geregelt.
 Für jeden Benutzer muss ein Dictionary eingerichtet werden.
 Beispiel:
    userlist = [
      {  'user'         : 'admin',
         'password'     : 'admin',
         'rights'       : ['admin']
         },
      {  'user'         : 'default',
         'password'     : '',
         'rights'       : ['default']
         },
      ]
      
 user:      Benutzername
 password:  Passwort
 rights:    Eine Liste der Rechte des Benutzers (siehe dazu auch Menü)
 HINT:
   Der user 'default' ist unbendingt notwendig. Wenn die Anwendung sowohl 
   geschützte als auch nur durch Passwort erreichbare Funktionen hat.
   Siehe dazu auch bei start.py  die Anweisung
   publicsites = ('/root/hintergrund','/authen')
   
Menü
-----
 Die Menüeintraege werden in der Klasse applib/WEB-INF/conf/menu.py deklariert.
 Die Menüs werden mittels des path Eintrages gegliedert.
 Die oberste Gliederungsstufe ist /root. Mit jeder Erweiterung wird eine weitere
 Stufe geschaffen. Alle Eintraege einer Stufe werden im Menü als Liste angezeigt.
 Controller:      Name des Controllers (ohne Dateierweiterung .py)
 Der Controller muss eim Dateisystem unter dem Verzeichnis mvc und dem Pfad eingetragen werden.
 Beispiel:
 Der Controller für das Beispiel list (path: /root/examples/list) ist im Verzeichnis
 <approot>/applib/WEB-INF/mvc/root/examples/list zu finden
 
 HINT:
   wird kein Controller eingetragen, so zeigt das Framework nur den Menüeintrag und 
   führt keine weiteren Aktionen durch.
   Dies ist entweder für das Prototyping notwendig. Es kann die Menüstruktutur getestet werden
   ohne dass Nutzcode produziert werden muss. 
   Oder wenn Sammel oder Einstiegsseiten mit weiteren Menüeintraegen notwendig sind.
   
 Rechte
 ------
 Jedem Menüeintrag kann ein oderer Mehrer Rechte zugeteilt werden.
 Wird der Eintrag rights leer gelassen, so kann der Controller von jedem genutzt werden.
 Die Rechte werden als Liste eingetragen.
 Beispiel:
         'rights':['admin']
 Dieser Menüeintrag wird nur angezeigt bzw. aktiviert, wenn der Benutzer das Recht 'admin' 
 zugewiesen bekommen hat (Siehe Benutzerverwaltung).
 
CONTROLLER
----------
 Ein Controller ist im wesentlichen ein Pythonskript welches vom Framework ausgeführt wird.
 Es besteht aus einer Klasse mit dem Controllername (siehe Menu) welches von der Klasse Controller erbt.
 Die Klasse muss eine Methode namens get besietzen, welche den Inhalt (Content) zurückliefert.

 Beispiel:
   from controller import Controller

   class RootController(Controller):

      def get(self):
         return 'Hallo Welt.'

 Um die Daten der oder des Viewer veralten zu koennen ist der Buffer self.html geschaffen.
 Dort wird im allgemeinen der gesamte Inhalt (Content) gesammelt.
 In Normalfall wird die lezte Zeile von get folgenden Inhalt haben:
         return self.html
 
 Die Anweisug 'render'.
 Um in den HTML Buffer zu schreiben kann die Methode self.render verwendet werden.
 Diese fügt am Ende des Buffers die als Parameter angegebenen Zeichenkette an.
 Beispiel:
    self.render("Hallo Welt.")
    
    
 Dem Controller wird als Bindingsparameter das Datenbankhandle übergeben:
   self.db (Siehe dazu auch Doamin)
    
VIEWER
------
 Der Viewer wird als eigenstaendige Datei im selben Verzeichnis wie der Controller gehalten.
 Er ist im wesentlichen ein HTML Schnippsel.
 Siehe dazu auch TEMPLATES
 Viewer sind eine Templatemaschine. Er kann auch Nutzcode enthalten.
 Code wird zwischen den Begrenzern <% und %> notiert.
 Es koennen beliebige Python seqünzen verwendet werden.
 
 Aufruf eines Viewers aus dem Controller.
 Beispiel:
 self.view('view.tpl')
 Der Viewer aktzeptiert drei Parameter.
 - Viewer filename
 - param optional ein Dictionary von Bindingparametern
 - importcgi (True/False) optional
   True es werden alle Parameter aus dem CGI in die Bindingsvariable übernommen.

DOMAIN
------
 Eine Domain stellt die Verbindung mit einer Datenbanktabelle dar.
 HINT:
   In der aktüllen Version wird nur Sqlite als Datenbank unterstützt.
   
 Die Domain ist im wesentlichen eine Klasse welche als Attribute die Datenbankfelder
 und eine Datenstruktur mit Metadaten (meta) enthaelt.
 Sie erbt von der Klasse Domain.
 
 Beispiel einer Domain:
 ----------------------
   # -*- coding: iso-8859-15 -*-
   from dbaccess   import *
   
   class LovDomain(Domain):
   (1)lovID     = None
      lovClass  = None
      lovKey    = None
      lovValue;  = None
      lovFlag1  = None
      lovFlag2  = None
      lovFlag3  = None
      lovFlag4  = None
      lovRemark = None

   (2)meta = {
         'tablename':'lov',
         'primarykey':'lovID',
         
      (3) 'fields':{
       (3.1)'lovID'       : {'dbfield':'lovID', 'type':'Integer'},
            'lovClass'    : {'dbfield':'lovClass'},
            'lovKey'      : {'dbfield':'lovKey'},
            'lovValue'    : {'dbfield':'lovValue'},
            'lovFlag1'    : {'dbfield':'lovFlag1'},
            'lovFlag2'    : {'dbfield':'lovFlag2'},
            'lovFlag3'    : {'dbfield':'lovFlag3'},
            'lovFlag4'    : {'dbfield':'lovFlag4'},
            'lovRemark'   : {'dbfield':'lovRemark'}
            }     
         }
    (4)def getLovValueUpper(self):
         return self.lovValue.upper()

   1: Die Domainfelder. Es müssen nicht alle moeglichen Datenbankfelder
      angegeben werden.

   2: Die Datenstruktur, welche die Metadaten zur Datenbantabelle angibt.
      tablename:     Name der Datenbanktabelle
      primarykey:    Datenbankname des Feldes in der Datenbanktabelle
                     welchen den Eindeutigen Schlüssel enthaelt.
   3: Fields
      Dies ist eine Datenstruktur die für jedes gewüschte Datenbankfeld
      eine Verbindung zum Domainfeld darstellt.
      Es ist moeglich, dass die Namen der Datenbankfelder und die der Domain
      unterschiedlich sind.

   3.1:
      Typenprüfung:
      Die Domain ist in der Lage den Datentyp zu prüfen.
      Dazu muss in den Metadaten beim Feld der gewüschte Datentyp angegeben werden.
      Gültige Datentypen sind:
	+ Integer			Integer
	+ Float				Float
	+ String			String
	+ Email				Eine E-Mailadress
	+ Date				Datumswert in ISO/ANSI
      Fehlt die Typeangabe, wird keine Typenprüfung vorgenommen.


      Die Typenprüfung kann angepasst werden.
      <obj>.typecheckNoneAllowed ::= [True|False]  Vorgabewert True
	Die Zuweisung von None ist erlaubt.

      <obj>.typecheckStrict ::=[True|False]	Vorgabewert ist True
        Die Typenprüfung wird ausgeschalten


   4: Beispiel einer Methode.
   
   
 Wesentliche Methoden der Domain
 -------------------------------
 Die Daten eines Datensatzes werden in einer Domain gespeichert.

 Die Domain kann dazu verwendet werden, Datensatzspezifische
 Funktionen als Methode zu halten. z.B. ORM

 Es bietet die Grundlegenden Funktionen
 - Oeffnen der Datenbank
 - lesen eines Datensatzes über seinen Primary Key
   oder ein beliebige where Klausel
 - Itteration von Datensaetzen (eachDomain)
   Mit der Moeglichkeit einen Filter einzusetzen und das Sortierkriterium anzugeben
 - Einfügen eines Datensatzes (insert)
 - Aenderung eines Datensatzes (update)
 - SQL Aggregatfunktionen (min, max, avg, sum, count)
 
 Initialisierung einer Domain
 ----------------------------
 lov = LovDomain(self.db)
 
 Detailierte Beispiele: Siehe 'examples'
 
TAGLIB
------
 Die Klasse Taglib stellt verschiedene Methoden zur einfacheren gestaltung von Webpages zu Verfügung.
 Diese Klasse wird jedem Viewer zu Verfügung gestellt.
 
 promptinput
 -----------
 Diese Methode ist das Schweizer Taschenmesser für Eingabefelder.
 Im Standardfall wird davon ausgeganben, dass die Prompt Input Seqünz in einer 
 HTML Tabelle geliefert werden soll. (<tr><td>[Prompt]</td><td>[Widget]</td></tr>
 Parameter:
      prompt=''
         String mit Prompt
      name=None
         Namensattribut des Widget (name="[name]")
      value=''
         Inhalt als String für das Widget
      maxlength=None
         Attribut maximale Eingabelaenge 
      size=None
         Attribut size
      css_class=None
         CSS Klassenname
      datasource=None
         Datenstrom für Select Widget.
         Dieser Datenstrom ist eine Liste von Listen welche die Optionen
         des Selecttags enthaelt.
           Element 1       Value Attribut
           Element 2       Textrepraesentation
           Element 3       (optional) als ausgewaehltes Element
      tr=True
         wird False übergeben unterbleibt das Einbetten in eine <tr>..</tr> Seqünz.
      style=None
         Styledefinition
      type='text'
         Type des Inputtags
            - text               <input type="text" ..>
            - displayandhidden   <input type="hidden" ..> und der Wert von value wird ausgegeben
            - select             <select..><option..> Seqünz
            - submit             <input type="submit"...
  form
  ----
  def form(self,):
  Gibt eine Formtag aus.
  Parameter:
   name=None
   style='display:inline;'
   css_class=None
   method='get'
  
  endform
  -------
  Gibt </form> aus
  
  table
  -----
  name          Name der Table
  style         Style Atritbute. Default nichts
  colgroup      Liefert nach dem Table-Tag ein Colgroup Tag
                mit der Anzahl der Cols mit Breite 1%, Abschliessend
                wird ein weitere Col Attribute mit dem Wert 99% eingefügt
  
  tablehead
  ---------
  Ausgabe der Tabellenkoepfe
  heads        ist eine Liste von Tabellenkoepfe
  css_class    CSS Klasse für TH Element
  style        Style Attribut für TH Element

  tablerow
  --------
  Liefert eine Tabellenzeile.
  Die Zeile werden als Zebra - Liste (unterschiedliche Farbhinterlegung) dargestellt.
  Es wird eine Liste von Spalteninhalten als Parameter übergeben.
  Der Parameter userzebra (True/False) Schalte Zebrafunktion ein/aus
  
  endtable
  --------
  Liefert </table>
  
  hidden
  ------
  Liefert einen Tag <input type="hidden" name="[name]" value="[value]" />
  
  gridbuttons
  -----------
  Um CRUD Anwendungen im Grid Format zu gestalten, werden für jeden 
  Datenbereich (Zeile) die Funktionsschaltflaechen "Edit" und "Delete" benoetigt.
  Diese Methode liefert zwei Formen für diese Funktionen.
  Parameter:
     id=None
     Kennung des Datensatzes
     addhidden=[]
     Zusaetzliche Hidden Parameter für die Form
     deletebutton=True;
     Deletebutton ausgeben
     editbutton=True
     Editbutton ausgeben
     
   editbutton
   ----------
   Liefert für eine Form für das Editieren eines Datensatzes.
   Diese Methode wird für CRUD Anwendungen welche List/Edit Methode
   verwenden benoetigt.
   Parameter:
   id=None
     ID des Datensatzes
   addhidden=[]
     Zusaetzliche Hidden Parameter
     
     
TEMPLATES
---------
 In den Templatedatein wird die HTML Seite mit Platzhalten beschrieben.
 Es muss eine gültige HTML enthalten sein.
 Die Templates werden im Verzeichnis <applib>/WEB-INF/templates gesucht.
 
 Im Normalfall sind mindestens zwei Templates deklariert:
   default.tpl          Das Template, welches für den Betrieb zustaendig ist.
   login.tpl            Ein Template, welches die Loginmaske enhaelt.
 
 Es koennen beliebig viele Templates verwaltet werden. Im Controller kann man mit 
 self.main.setContainer(<filename>) zwischen unterschiedlichen Templates umschalten.
 
 Platzhalter
 -----------
 Platzhalter werden mit einem Dollarzeichen gekennzeichnet und koennen an beliebiger 
 Stelle des Templates stehen.
  $stylesheet           Es werden die Stylesheet Eintraege im HTML-Hader eingetragen.
                        Vorgabewert:
                        <link rel="stylesheet" href="../css/skin/normal/normal.css" type="text/css" />
                        <link rel="stylesheet" href="../css/skin/normal/add.css" type="text/css" />
                        Diese Einstellungen koennen in der Konfigurationsdatei überschrieben und 
                        erweitert werden.
  $body                 Wird durch den Inhalt des durch einen Controller gelieferten Content
                        ersetzt
  $menu                 Menü
  $flash                Zeigt den Inhalt des Flashstrings.
                        Die Formatierung kann durch überschreiben in der Konfigurations
                        Datei geaendert werden.
  $backlink             Inhalt des Backling Eintrags
  $sid                  Sessionid
  $user                 Benutzerkennung
  $sideboxes            Inhalt der Sideboxes

pyMFrame ein Webframework in Python