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.1/downloads/current/index tg.devtools

Quick start a project

paster quickstart

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

Folder Structure

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

addressbook/
|-- MANIFEST.in
|-- 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

http://turbogears.org/2.1/docs/_images/tg2_files.jpg

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

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.

tg2welcome2.png

Database


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

 sqlalchemy.url=postgres://username:password:port@hostname/databasename
 sqlalchemy.url=mysql://username:password@hostname:port/databasename

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

URL

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()


    @expose('addressbook.templates.index')
    def index(self):
        return dict(page='index')

    @expose('addressbook.templates.about')
    def about(self):
        return dict(page='about')
    @expose('addressbook.templates.addaddress')
    def addaddress(self,**kw):
        return dict(page='addaddress')

``@expose``
  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.

Template

cd addressbook/templates/
cp index.html addaddress.html

 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.

Widget

from tw.forms import TableForm, TextField, CalendarDatePicker, SingleSelectField, TextArea
from tw.api import WidgetsList
#Validator
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"),
                         ("Male"),
                        )
        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.

Template

${tmpl_context.address_form()}

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

tg2address_form.png

Controller

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:

    @expose('addressbook.templates.addaddress')
    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.tmpl_context.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.tmpl_context.form instead and use c.form in your template
        pylons.tmpl_context.address_form = address_form
        return dict(page='addaddress')
    @validate(address_form, error_handler=addaddress)
    @expose()
    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']
        DBSession.add(address)
        DBSession.commit()
        flash("Successfully saved.")
        raise redirect("addaddress")
    @expose()
    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.

DataGrid

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'),
                ('Address','Address'),
                ('City','City'),
                ('State','State'),
                ('Zip Code','ZipCode'),
                ('Gender','Gender')]

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

@expose('addressbook.templates.addresses')
    def addresses(self, **kw):
        """This function will display our data in a grid"""
        all=DBSession.query(Addressbook).all()
        pylons.tmpl_context.address_grid=DataGrid(fields = address_grid)
        pylons.tmpl_context.address_data=DBSession.query(Addressbook).all()
        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:

toscawidget_data_grid.png

Testing/UnitTest

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

OK

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


OK

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.

Addresses

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)