Differences between revisions 70 and 72 (spanning 2 versions)
Revision 70 as of 2009-07-09 14:48:29
Size: 17966
Comment: Suggestions and typo from Laurin Killian
Revision 72 as of 2009-09-06 02:49:20
Size: 18048
Editor: localhost
Comment: converted to 1.6 markup
Deletions are marked like this. Additions are marked like this.
Line 128: Line 128:
Line 159: Line 160:
inline:tg2welcome2.png {{attachment:tg2welcome2.png}}
Line 341: Line 342:
inline:tg2address_form.png {{attachment:tg2address_form.png}}
Line 434: Line 435:
inline:toscawidget_data_grid.png {{attachment:toscawidget_data_grid.png}}

First Web Application in Turbogears2

Install TurboGears2

Create virtualenv, activate it, and install all the packages.

virtualenv --no-site-packages tg2env
cd tg2env/
source bin/activate
easy_install -i http://www.turbogears.org/2.0/downloads/current/index tg.devtools

Quick start a project

  • Create tg2 package using quickstart:

paster quickstart
  • Enter the Project name, and choose if you want identity to be enabled. You should see something like this.

Enter project name: addressbook
Enter package name [addressbook]:
Do you need authentication and authorization in this project? [yes]
Selected and implied templates:
  • Done setting it up.

Folder Structure

This will create a skeleton of you project. You address book project has the following structure::

|-- README.txt
|-- addressbook
|   |-- __init__.py
|   |-- config
|   |   |-- __init__.py
|   |   |-- app_cfg.py
|   |   |-- deployment.ini_tmpl
|   |   |-- environment.py
|   |   `-- middleware.py
|   |-- controllers
|   |   |-- __init__.py
|   |   |-- controller.template
|   |   |-- error.py
|   |   |-- root.py
|   |   |-- secure.py
|   |   `-- template.py
|   |-- i18n
|   |   `-- ru
|   |       `-- LC_MESSAGES
|   |           `-- addressbook.po
|   |-- lib
|   |   |-- __init__.py
|   |   |-- app_globals.py
|   |   |-- base.py
|   |   `-- helpers.py
|   |-- model
|   |   |-- __init__.py
|   |   |-- auth.py
|   |   `-- model.template
|   |-- public
|   |   |-- css
|   |   |   `-- style.css
|   |   |-- favicon.ico
|   |   `-- images
|   |       |-- contentbg.png
|   |       |-- error.png
|   |       |-- header_inner2.png
|   |       |-- headerbg.png
|   |       |-- info.png
|   |       |-- inputbg.png
|   |       |-- loginbg.png
|   |       |-- loginbottombg.png
|   |       |-- loginheader-right.png
|   |       |-- menu-item-actibg-first.png
|   |       |-- menu-item-actibg.png
|   |       |-- menu-item-border.png
|   |       |-- menubg.png
|   |       |-- ok.png
|   |       |-- pagebg.png
|   |       |-- star.png
|   |       |-- strype2.png
|   |       |-- under_the_hood_blue.png
|   |       `-- warning.png
|   |-- templates
|   |   |-- __init__.py
|   |   |-- about.html
|   |   |-- authentication.html
|   |   |-- debug.html
|   |   |-- error.html
|   |   |-- footer.html
|   |   |-- header.html
|   |   |-- index.html
|   |   |-- login.html
|   |   |-- master.html
|   |   `-- sidebars.html
|   |-- tests
|   |   |-- __init__.py
|   |   |-- functional
|   |   |   |-- __init__.py
|   |   |   |-- test_authentication.py
|   |   |   `-- test_root.py
|   |   `-- models
|   |       |-- __init__.py
|   |       `-- test_auth.py
|   `-- websetup.py
|-- addressbook.egg-info
|   |-- PKG-INFO
|   |-- SOURCES.txt
|   |-- dependency_links.txt
|   |-- entry_points.txt
|   |-- paster_plugins.txt
|   |-- requires.txt
|   `-- top_level.txt
|-- development.ini
|-- ez_setup
|   |-- README.txt
|   `-- __init__.py
|-- setup.cfg
|-- setup.py
|-- setup.pyc
`-- test.ini


Inside your addressbook folder you find another addressbook folder and inside of it you will find::

   Config -Here you configure your application to the requirements you might have.
   Controllers - Here your manipulate data, setup your urls, define what gets passed to what, your whole application flow etc.
   Model - Here you define all your database models
   Public - Here you keep all your static files, your css modules, your images.
   Templates - Here you store your genshi template files.
   i18n - Here you define your international settings.
   lib- This is where you can attach plugins like turbomail, and configure global settings for you application, and setup helpers for templates. 
   tests - Here you define your nose test that you can write for your app.

Start the app

  • If this is your first time running the app you need to run setup.py. You should be in a folder that has the development.ini and setup.py

cd addressbook
python setup.py develop

To start the project we will use the following command.:

paster serve --reload development.ini

   - paster provides a simple mechanism for running a TurboGears projects.
   - server tells paster to start the webserver
   --reload tells paster to reload the pages if one of the files have changed.
   -development.ini is a general configuration file for turbogears2

You should be able to open your favorite browser and see the initial turobgears website. Visit this site: http://localhost:8080/ You should see you site running.



DB Connection

*Your Database configuration is located in development.ini file under

 sqlalchemy.url = sqlite:///%(here)s/devdata.db
*You can change this url to your version of database

  • When you have your database connection ready we are ready to design simple database.

DB Design

*We need to create our database structure. We do it in model.py First you need to copy the model.template to model.py and insert the code for your table

cd addressbook/model
cp model.template model.py
*Inside of it change the foo_table, Class Foo and mapper in a following way

from pylons import config
#from sqlalchemy import *
import sqlalchemy
from sqlalchemy.orm import mapper, relation
from addressbook.model import metadata

# Normal tables may be defined and mapped at module level.
# Our Addressbook table definition
from datetime import datetime
addressbook_table = sqlalchemy.Table("Addressbook", metadata,
    sqlalchemy.Column('Address_Sid', sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column('FirstName', sqlalchemy.Unicode(40),nullable=False),
    sqlalchemy.Column('LastName', sqlalchemy.Unicode(40),nullable=False),
    sqlalchemy.Column('MaidenLastName', sqlalchemy.Unicode(40)),
    sqlalchemy.Column('Email', sqlalchemy.Unicode(80),nullable=False),
    sqlalchemy.Column('Address', sqlalchemy.Unicode(80),nullable=False),
    sqlalchemy.Column('City', sqlalchemy.Unicode(80),nullable=False),
    sqlalchemy.Column('State', sqlalchemy.String(2),nullable=False),
    sqlalchemy.Column('ZipCode', sqlalchemy.Integer,nullable=False),
    sqlalchemy.Column('DOB', sqlalchemy.Date(),nullable=False),
    sqlalchemy.Column('Gender', sqlalchemy.Unicode(6),nullable=False),
    sqlalchemy.Column('Description', sqlalchemy.Unicode(255),nullable=False),
    sqlalchemy.Column('Created', sqlalchemy.Integer, default=int(time.time())),
    sqlalchemy.Column('Last_UpdatedDate', sqlalchemy.Date, default=datetime.now().date(), onupdate=func.now().date()),
#This is an empty class that will become our data class
class Addressbook(object):
    def __init__(self, **kw):
        """automatically mapping attributes"""
        for key, value in kw.iteritems():
            setattr(self, key, value)
#Mapping of Table to Python Object Class
mapper(Addressbook, addressbook_table)
# Classes for reflected tables may be defined here, but the table and
# mapping itself must be done in the init_model function.

Create Database

*Lets create the tables in our database by running the following command::

paster setup-app development.ini


Lets create a url where we will add addresses to our addressbook. Lets make it http://localhost:8080/addaddress We need to create a function in a root.py in controllers folder. Our new function will look just like index but with a different name. See below code.

class RootController(BaseController):
   The root controller for the addressbook application.

   All the other controllers and WSGI applications should be mounted on this
   controller. For example::

       panel = ControlPanelController()
       another_app = AnotherWSGIApplication()

   Keep in mind that WSGI applications shouldn't be mounted directly: They
   must be wrapped around with :class:`tg.controllers.WSGIAppController`.


    secc = SecureController()
    admin = Catwalk(model, DBSession)
    error = ErrorController()

    def index(self):
        return dict(page='index')

    def about(self):
        return dict(page='about')
    def addaddress(self,**kw):
        return dict(page='addaddress')

  This line defines which template we will use for this url. The template we use: addressbook/templates/addaddress.html
``def addaddress(self):``
  This adds our url http://localhost:8080/addaddress
``return dict(page='addaddress')``
  The dict returns data to the template in a python dictionary structure 'key=value'. We returned variable called page.
  • Above will set your url. Now you need to create/modify template html to show what you want and do some code in address to do what you want it to do with the data.


  • Now that we have defined which template we will use, lets create the actual html file and start our app to make sure everything is working.
  • Lets create a template real quick:

cd addressbook/templates/
cp index.html addaddress.html
  • Lets start the app and see if our url works:

 paster serve --reload development.ini

Ok. It worked. You should see the "Now Viewing:addaddress" This is using the page variable that we passed to the template. Lets create a widget aka the form where we will provide information and submit it.


  • Lets create a widget form that will be asking for our addresses. Add the following to the top of our controller/root.py. For now we will be adding it to root.py but as you get more familiar you will be putting these in a seperate file:

from tw.forms import TableForm, TextField, CalendarDatePicker, SingleSelectField, TextArea
from tw.api import WidgetsList
from formencode.validators import Int, NotEmpty, DateConverter, DateValidator,PostalCode,String,Email

class AddressForm(TableForm):
    # This WidgetsList is just a container
    class fields(WidgetsList):
        FirstName = TextField(validator=NotEmpty)
        LastName = TextField(validator=NotEmpty)
        MaidenLastName = TextField(validator=String)
        Email = TextField(validator=Email)
        Address = TextField(validator=NotEmpty)
        City = TextField(validator=NotEmpty)
        State = TextField(validator=NotEmpty)
        #Or you could do:
        #StateChoices = (("IL"),
        #                 ("IN"),
        #                 ("MS"),
        #                )
        #State = SingleSelectField(options=StateChoices, validator=NotEmpty)
        ZipCode = TextField(size=6, validator=PostalCode())
        DOB = CalendarDatePicker(validator=DateConverter())
        GenderChoices = (("Female"),
        Gender = SingleSelectField(options=GenderChoices)
        Description = TextArea(attrs=dict(rows=3, cols=25))

#then, we create an instance of this form
address_form = AddressForm("address_form", action='saveaddress')

It will send the results to "saveaddress" which we have to create in root.py. But for now lets create our template.


  • Lets edit our template and add our form in there. We don't have to return the form as dictionary we can set pylons.c.myformname and use template_context.myformname in a template. Lets do just that. Edit our addressbook/templates/addaddress.html and add the following line:


Above will display our form in the template. The address_form is equivalent to pylons.c.address_form in a root.py. The template will look like:



Lets modify our root.py again and change the def addaddress and add def saveaddress functions. First make sure you have the following imported at the top of root.py:

from addressbook.lib.base import BaseController
from tg import expose, flash
from pylons.i18n import ugettext as _
from tg import redirect, validate
import pylons
from addressbook.model import DBSession, metadata
from addressbook.model import Addressbook

Our new change modifies addaddress and adds the save function which should look like this:

    def addaddress(self,**kw):
        """Form to add new record"""
        # Flash updates the status on the page. Try modifying it to something you want.
        flash("Hello Addressbook!")
        # This is where we attach the form to pylons.c.something and whatever you attach will be available in the template as tmpl_context.something
        # Passing the form in the return dict is no longer required, you can
        # set pylons.c.form instead and use c.form in your template
        pylons.c.address_form = address_form
        return dict(page='addaddress')
    @validate(address_form, error_handler=addaddress)
    def saveaddress(self, **kw):
        """Save it to the database"""
        address = Addressbook()
        address.FirstName = kw['FirstName']
        address.LastName = kw['LastName']
        address.MaidenLastName = kw['MaidenLastName']
        address.Email = kw['Email']
        address.Address = kw['Address']
        address.City = kw['City']
        address.State = kw['State']
        address.ZipCode = kw['ZipCode']
        address.DOB = kw['DOB']
        address.Description = kw['Description']
        address.Gender = kw['Gender']
        flash("Successfully saved.")
        raise redirect("addaddress")
    def addresses(self, **kw):
        """List our addressbook"""
        return dict()

The addaddress will now display our widget in out template and when you click on Save it will send the data to saveaddress. Saveaddress will save the data into database. The only thing left now is to show the data that is in our addressbook.


Now we need to display our data. We will do that with datagrid from toscawidget. First thing we need to do is to import proper programs. Then we will define what will be displayed. Add the above lines above our root class:

from tw.forms.datagrid import DataGrid

address_grid = [('First Name','FirstName'),
                ('Last Name','LastName'),
                ('Zip Code','ZipCode'),

Then Lets modify our addresses function to be something like this:

    def addresses(self, **kw):
        """This function will display our data in a grid"""
        pylons.c.address_grid=DataGrid(fields = address_grid)
        return dict(page='addresses')

The address_grid will render the data, while address_data contains actual data. Now lets create addresses.html that will display our data.:

cd addressbook/tempalates
cp index.html addresses.html

Add the following somewhere in a code:

<p>${tmpl_context.address_grid(tmpl_context.address_data)} </p>

Now start the app again and go to http://localhost:8080/addresses

The data grid looks like this:



Testing in turbogears2 is done by nosetests. You already have a folder designed for what you need to do. You can test your application for errors in few simple steps. The test files are located in addressbook/tests/

Run the tests using the following command:

 python setup.py nosetests

You should see tests being run and at the end you will find:

Ran 0 tests in 0.045s


Test Index

You can add more tests to file yourapp/tests/functional/. We already have a test that checks for /index page. Lets create a another test for our application:

cp addressbook/tests/functional/test_root.py addressbook/tests/functional/test_addressbook.py

Inside change the first test and delete the rest:

class TestPageData(TestController):

   def test_addressbook(self):
       resp = self.app.get('/addaddress')
       ns = resp.namespace
       assert 'page' in ns
       assert ns['page'] == 'addaddress'

Save and run the tests again:

python setup.py nosetests

You will see:

Ran 18 tests in 1.981s


Done. You have created your first test. With the above code you can make sure each page is returning before you upload to production server.


Now add the second test case to our TestPageData class. The tests case start with test_ :

 def test_addresses_page_data(self):
       resp = self.app.get('/addresses')
       ns = resp.namespace
       #See if there is a page return
       assert 'page' in ns
       #See if the page return is called addresses.
       assert ns['page'] == 'addresses'
       #Test if the template is there.
       assert resp.template_name == 'addressbook.templates.addresses'

MyWiki: TurboGears2/Addressbook (last edited 2011-02-01 22:00:14 by LukaszSzybalski)