Level 2

In this phase you will write a basic version of the web application that can
display but not create job listings. This means we don't yet have to worry about login
and sessions but that you must interface to the database to lists positions.

Following the model-view-controller architecture, the first thing that you'll
implement is the database model. This is contained in a moduleinterface.py
with all of the code to retrieve and store positions in the database.
You will then implement the views (templates) and controllers for the web application
that makes use of the models present the data on the web.

All of the work you do will be tested using unit tests. For the database interface,
there are straightforward unit tests of the functions that you will write. To test the
behaviour of the web application we'll use functional testing that requests your pages
and checks that they have certain contents, and that we can login and position
messages. We will do this using a module called WebTest that is designed specifically
for functional testing of Python web applications.

Unit Tests

All procedures will be implemented in
the moduleinterface.py. A version has been supplied that contains the procedure
stubs only.

When we refer to a database connection below we mean the connection returned byCOMP249Dbfrom thedatabasemodule that we provide. This is just a
regular SQLite database connection, but the code we provide ensures we can
control which database you are using for testing purposes.

• position_list

  There is a functionposition_list(db, limit=10).dbis a database connection
  and the optional argument limit is an integer. The function returns a list of tuples
  representing the positions stored in the database, each tuple contains:(id, timestamp, owner,
  title,
  location, company, description).
  Messages are returned in reverse
  order of the timestamp, most recent first.

• position_get

  There is a functionposition_get(db, id).dbis a database connection
  andidis an integer position identifier.
  The function returns a tuple
  representing the position with the given id,
  the tuple contains:(id, timestamp, owner, title,
  location, company, description).

  If theiddoes not match a record in the
  database, the function should returnNone.

• position_add

  There is a functionposition_add(db, usernick, title, location, company, description).dbis a database connection, the argumentusernickis a user name andtitle, location, companyanddescriptionare the values of
  the respective fields in the positions table. The function adds the new position
  to the database.

  Ifusernickdoes not a user in the users table, no new record should
  be created and the function should returnFalse

  If the record is added successfully, the function should returnTrue.

Functional requirements

The functional requirements describe what a user should be able to see and do
on the web application. They describe what happens when you load a particular URL
or submit a form in a page. There are automated tests to check that you have
implemented this functionality correctly.

• Home Page List of positions

  As a visitor to the site, when I load the home page (URL /) I see a list of
  up to 10 positions in order of their timestamps, most recent first. Each position
  must include the position timestamp, title, owner and the first 100 characters of
  the text of the position description. At the end of each listing
  should be a link to view the entire position with the text "Read More" and the
  url/positions/DD
  whereDDis the position id.

  The list of positions that appears should be the
  result of a call toposition_listwhich will extract the most recent
  10 positions from the database.

• Position Page

  As a visitor to the site, I can click on the "Read More" link after a position
  description on the home page, I see a page with the full description of the
  position at the URL/positions/DDwhereDDis the position id.

  The position page should contain all of the database fields for the position, laid out
  in a readable way. It should also contain a link to return to the main page.

Your Task

To achieve these requirements you need to write code ininterface.pyto implement the
different functions to interface to the database. Run the unit tests inlevel2_unit.py
to check whether you have met the requirements.

Once you have a working version ofinterface.pyyou can move on to write the
application itself inmain.py. Take each required page in turn and write the
code to generate the content using the functions you have written. You can check
the functional requirements yourself and run the unit tests inlevel2_functional.py
to validate that you've met the requirements.

• Python Web Applications.

• Python and SQLite describes the
  way to send queries to SQLite and get results back.

• Generating HTML Pages looks at
  the Bottle page templating system.

• Testing Python Programs covers
  running unit tests.