This semester we will be writing a simple job board application called
Jobs! that allows users to post job position descriptions.
To give you an idea of what the application does, there is a demonstration
version at http://comp249.stevecassidy.net/.
Since this is your first significant web application, we've cut down the
features to make it manageable. However we maintain the core of the
application and what you write could be extended to something like a real
product. Your application will support logging in users, posting jobs
and viewing job listings. We don't require you
to be able to register new users or handle user profile changes etc.
You are given a 'starter kit' which contains the bare outline of the
application. From this starting point, you will implement the full site
in phases according to a detailed set of functional requirements. At the end
of each phase, a set of automated tests will be used to see if you have
met the criteria for that phase. Some of the marks for this project
will be based on your passing these automated tests.
While this task may seem quite daunting, it should be achievable if you
work through the examples we have provided and work on the problem
bit by bit. We have run similar tasks in the past in COMP249 and most
students have succeeded in getting a working system going.
Level 1
The first phase of the project involves writing a basic web application
that can serve two pages.
Requirements
Level 2
In this phase you will interface to a backend database and provide
views that list all positions.
Requirements
Level 3
The next phase of development adds the ability to login to the application
and post new position listings.
Requirements
Going Further
This is just the start of the project. In project 3 you will rewrite
the application to use Javascript in the front end and connect to a back-end
service that I provide. There will be scope to implement new features when
you tackle that project.
Required Python Modules
This project makes use of the following Python modules that you will need to install to
complete the work and run the tests:
Bottle – web development framework
Bottle SQLite plugin
– for database access from Bottle
WebTest – for testing web applications
You can use the module installer in PyCharm to install these libraries for your project.
Starter Kit
The starter kit is a zip file containing a set of Python
files to get you started on this project. These files provide a framework for you
to work within, you will need to add more code of your own and possibly more
modules (Python files, templates) to complete the implementation.
You can download the starter pack here: comp249-2018-jobs-starter.
It is also available as a Bitbucket project comp249-2018-jobs-starter,
if you are a git user you could fork the repository from there – please be sure to keep your own version
private if you keep your work on Bitbucket (or Github).
The contents of the starter pack are as follows:
database.py– code to create the database and load sample data
main.py– main application script with a simple example
interface.py– stubs for the level 2 required functions
users.py– stubs for the level 3 required functions
positions.json– sample job listings taken from the github jobs API.
level1_functional.py– functional tests for Level 1
level2_functional.py– functional tests for Level 2
level2_unit.py– unit tests for Level 2
level3_functional.py– functional tests for Level 3
level3_unit.py– unit tests for Level 3
static– directory containing a sample CSS file
Thedatabase.pymodule contains code to create the database
tables that you will need for the project and load in some sample data from
thepositions.jsonfile. You need to run this file to create
the database when you start the project. You can also re-run it if
you want to reset your database to a known state.
The database contains the following tables:
users: fieldsnick(user nickname),password,avatar(URL of an avatar image)
sessions: fieldssessionid,usernick, where usernick is
a reference to the nick field in the users table
posts: fieldsid,timestamp,usernick,content
There are also two other tablesvotesandfollowsthat are not
used in the core requirements but that you can use if you wish to implement further features.
Each user is identified by a nickname that is stored in thenickfield in theuserstable. This field is used as a foreign key in other tables to refer to
the user. To select data from both tables you will need to do a query with a join.
Thepositionstable deserves further comment. Theidfield is an auto-incremented
integer id for each post, you don't need to give this a value, it will automatically get a new unique value
when you insert a row. Thetimestampfield will also default to the current time
and date in the format '2015-02-20 01:45:06' if you don't provide a value when you add a row. So,
to add a row to thepositionstable you just need:
sql = """INSERT INTO positions (owner, title, location, company, description) VALUES (?, ?, ?, ?, ?)"""
cursor.execute(sql, [usernick, title, location, company, description])
db.commit()
The code as provided includes a sample Bottle
application which you can run. It doesn't do much other than generate a static page that
links to a copy of these notes. This is your starting point for development and
you should write your code so thatmain.pyis the main application (when
I run your code, this is what I'll look for).
You can run the functional and
unit tests (level1_functional.pylevel2_unit.py) to check that
you have met the requirements at each level. To do this,
open the file in PyCharm and click 'Run', choose to run as "Python unit-test". Alternately,
run them from the command line eg.python level1_functional.py.
Note that if you follow the written requirements set out in the pages linked above, you
should pass the functional tests. A reasonable way to work would be to read and implement
each functional requirement in turn and then run the functional tests when you are done as
a check.
Submission
You will submit this work in two parts: after you have completed Level 2, and after you
have completed Level 3. The Level 2 submission is intended to check on your progress
with the project so that we can provide you with feedback and identify anyone
who needs support. See iLearn for the dates of these submissions.
For each submission you should submit a zip file
with the same structure as the starter pack. We will expect to runmain.pyto see your application. Include any support files that you need for your application
to work. A good idea would be to unpack your zip file at a new location and try to
run it yourself.
Grading the project
This project is worth 20% of the final marks for COMP249.
A total of 12 marks will be entirely based on achieving the stated functional
and unit-test requirements and passing the automated tests.
The remaining 8 marks will be based on the quality of the code and documentation that you
provide, and on the appearance of your web application.
Each automated test is worth 0.5 marks; there is a total
of 24 tests giving 12 marks in total. The breakdown of
tests for each level is as follows:
Level Functional Tests Unit Tests Marks
1 4 – 2
2 3 5 4
3 5 7 6
To pass this project you must pass all of the automated tests..
This may seem like a tough requirement but without passing these tests
you don't have a working web application.
The remaining 8 marks will decide whether you get a Credit
or Distinction/High Distinction for the project. The criteria are:
Appearance (3 Marks)
Your web application is visually well designed and consistently styled.
For a Credit, you will have applied a clear design to all pages in your
application. For a D/HD your design will include some novelty
or use advanced aspects of HTML/CSS and possibly Javascript.
Code Quality (3 marks)
Your code is
readable and well structured. For a Credit, we should not have
any trouble working out how you implemented a given feature. For a
D/HD, you will have thought hard about how the application as
a whole fits together and made good use of modules.
Documentation (2 Marks)
You have provided appropriate documentation. For a Credit, you
will have used documentation strings and in-line comments where
appropriate in your code. For D/HD, you will have provided documentation of
your application that would be useful to a future developer, your
documentation will include
functional tests in the form of user stories for your new features.
Your final grade will be calculated
based on your performance against the above criteria.
Jobs is a class project for COMP249 at Macquarie University
Jobs uses Twitter Bootstrap
