Merge lp:~zack-krejci/healthscapes/trunk into lp:healthscapes/trunk

[Zack]

=== added directory 'controllers'
=== removed directory 'controllers'
=== added file 'controllers/admin.py'
--- controllers/admin.py	1970-01-01 00:00:00 +0000
+++ controllers/admin.py	2011-01-24 22:41:50 +0000
@@ -0,0 +1,1241 @@
+# -*- coding: utf-8 -*-
+
+"""
+    Admin Controllers
+"""
+
+import cPickle as pickle
+import csv
+from gluon.admin import *
+from gluon.fileutils import listdir
+
+module = "admin"
+
+# Options Menu (available in all Functions' Views)
+# - can Insert/Delete items from default menus within a function, if required.
+response.menu_options = admin_menu_options
+
+# S3 framework functions
+# -----------------------------------------------------------------------------
+def index():
+
+    """ Module's Home Page """
+
+    module_name = deployment_settings.modules[module].name_nice
+    response.title = module_name
+    return dict(module_name=module_name)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def setting():
+
+    """ RESTful CRUD controller """
+
+    resourcename = request.function
+    tablename = "s3_" + resourcename
+    table = db[tablename]
+
+    table.admin_name.label = T("Admin Name")
+    table.admin_email.label = T("Admin Email")
+    table.admin_tel.label = T("Admin Tel")
+    #table.utc_offset.label = T("UTC Offset")
+    table.theme.label = T("Theme")
+    table.theme.comment = DIV(A(T("Add Theme"), _class="colorbox", _href=URL(r=request, c="admin", f="theme", args="create", vars=dict(format="popup")), _target="top", _title=T("Add Theme"))),
+    #table.archive_not_delete.label = T("Archive not Delete")
+    #table.archive_not_delete.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Archive not Delete") + "|" + T("If this setting is enabled then all deleted records are just flagged as deleted instead of being really deleted. They will appear in the raw database access but won't be visible to normal users."))
+    #table.debug.label = T("Debug")
+    #table.debug.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Debug") + "|" + T("Switch this on to use individual CSS/Javascript files for diagnostics during development."))
+    #table.self_registration.label = T("Self Registration")
+    #table.self_registration.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Self-registration") + "|" + T("Can users register themselves for authenticated login access?"))
+    #table.security_policy.label = T("Security Policy")
+    #table.security_policy.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Security Policy") + "|" + T("The simple policy allows anonymous users to Read & registered users to Edit. The full security policy allows the administrator to set permissions on individual tables or records - see models/zzz.py."))
+    #table.audit_read.label = T("Audit Read")
+    #table.audit_read.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Audit Read") + "|" + T("If enabled then a log is maintained of all records a user accesses. If disabled then it can still be enabled on a per-module basis."))
+    #table.audit_write.label = T("Audit Write")
+    #table.audit_write.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Audit Write") + "|" + T("If enabled then a log is maintained of all records a user edits. If disabled then it can still be enabled on a per-module basis."))
+
+    s3.crud_strings[tablename] = Storage(
+        title_update = T("Edit Settings"),
+        msg_record_modified = T("Settings updated"),
+        label_list_button = None)
+
+    s3xrc.model.configure(table,
+                          deletable=False,
+                          listadd=False,
+                          #onvalidation=theme_check,
+                          #update_next = URL(r=request, args=[1, "update"])
+                          onaccept=theme_apply)
+
+    output = s3_rest_controller("s3", resourcename, list_btn=None)
+    return output
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def theme():
+    """ RESTful CRUD controller """
+    resource = "theme"
+    tablename = module + "_" + resource
+    table = db[tablename]
+
+    # Model options
+    table.name.label = T("Name")
+    #table.logo.label = T("Logo")
+    #table.logo.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Logo") + "|" + T("Name of the file (& optional sub-path) located in static which should be used for the top-left image."))
+    #table.header_background.label = T("Header Background")
+    #table.header_background.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Header Background") + "|" + T("Name of the file (& optional sub-path) located in static which should be used for the background of the header."))
+    #table.footer.label = T("Footer")
+    #table.footer.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Footer") + "|" + T("Name of the file (& optional sub-path) located in views which should be used for footer."))
+    table.col_background.label = T("Background Colour")
+    table.col_txt.label = T("Text Colour for Text blocks")
+    table.col_txt_background.label = T("Background Colour for Text blocks")
+    table.col_txt_border.label = T("Border Colour for Text blocks")
+    table.col_txt_underline.label = T("Colour for Underline of Subheadings")
+    table.col_menu.label = T("Colour of dropdown menus")
+    table.col_highlight.label = T("Colour of selected menu items")
+    table.col_input.label = T("Colour of selected Input fields")
+    table.col_border_btn_out.label = T("Colour of bottom of Buttons when not pressed")
+    table.col_border_btn_in.label = T("Colour of bottom of Buttons when pressed")
+    table.col_btn_hover.label = T("Colour of Buttons when hovering")
+
+    # CRUD Strings
+    ADD_THEME = T("Add Theme")
+    LIST_THEMES = T("List Themes")
+    s3.crud_strings[resource] = Storage(
+        title_create = ADD_THEME,
+        title_display = T("Theme Details"),
+        title_list = LIST_THEMES,
+        title_update = T("Edit Theme"),
+        title_search = T("Search Themes"),
+        subtitle_create = T("Add New Theme"),
+        subtitle_list = T("Themes"),
+        label_list_button = LIST_THEMES,
+        label_create_button = ADD_THEME,
+        msg_record_created = T("Theme added"),
+        msg_record_modified = T("Theme updated"),
+        msg_record_deleted = T("Theme deleted"),
+        msg_list_empty = T("No Themes currently defined"))
+
+    s3xrc.model.configure(table,
+                          #onvalidation=theme_check,
+                          #list_fields=["id", "name", "logo", "footer", "col_background"],
+                          list_fields=["id", "name", "col_background"],
+                          )
+
+    return s3_rest_controller(module, resource)
+    s3xrc.model.clear_config(table, "onvalidation")
+
+
+# -----------------------------------------------------------------------------
+def theme_apply(form):
+    "Apply the Theme specified by Form"
+    if form.vars.theme:
+        # Valid form
+        # Relevant paths
+        template = os.path.join(request.folder, "static", "styles", "S3", "template.css")
+        tmp_folder = os.path.join(request.folder, "static", "scripts", "tools")
+        out_file = os.path.join(request.folder, "static", "styles", "S3", "sahana.css")
+        out_file2 = os.path.join(request.folder, "static", "styles", "S3", "sahana.min.css")
+        # Check permissions
+        if not os.access(template, os.R_OK):
+            session.error = T("Template file %s not readable - unable to apply theme!" % template)
+            redirect(URL(r=request, args=request.args))
+        if not os.access(tmp_folder, os.W_OK):
+            session.error = T("Temp folder %s not writable - unable to apply theme!" % tmp_folder)
+            redirect(URL(r=request, args=request.args))
+        if not os.access(out_file, os.W_OK):
+            session.error = T("CSS file %s not writable - unable to apply theme!" % out_file)
+            redirect(URL(r=request, args=request.args))
+        if not os.access(out_file2, os.W_OK):
+            session.error = T("CSS file %s not writable - unable to apply theme!" % out_file2)
+            redirect(URL(r=request, args=request.args))
+        # Read in Template
+        inpfile = open(template, "r")
+        lines = inpfile.readlines()
+        inpfile.close()
+        # Read settings from Database
+        theme = db(db.admin_theme.id == form.vars.theme).select(limitby=(0, 1)).first()
+        default_theme = db(db.admin_theme.id == 1).select(limitby=(0, 1)).first()
+        #if theme.logo:
+        #    logo = theme.logo
+        #else:
+        #    logo = default_theme.logo
+        #if theme.header_background:
+        #    header_background = theme.header_background
+        #else:
+        #    header_background = default_theme.header_background
+        # Write out CSS
+        ofile = open(out_file, "w")
+        for line in lines:
+            #line = line.replace("YOURLOGOHERE", logo)
+            #line = line.replace("HEADERBACKGROUND", header_background )
+            # Iterate through Colours
+            for key in theme.keys():
+                if key[:4] == "col_":
+                    if theme[key]:
+                        line = line.replace(key, theme[key])
+                    else:
+                        line = line.replace(key, default_theme[key])
+            ofile.write(line)
+        ofile.close()
+
+        # Minify
+        from subprocess import PIPE, check_call
+        currentdir = os.getcwd()
+        os.chdir(os.path.join(currentdir, request.folder, "static", "scripts", "tools"))
+        import sys
+        # If started as a Windows service, os.sys.executable is no longer python
+        if ("win" in sys.platform):
+            pythonpath = os.path.join(sys.prefix, "python.exe")
+        else:
+            pythonpath = os.sys.executable
+        try:
+            proc = check_call([pythonpath, "build.sahana.py", "CSS", "NOGIS"], stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=False)
+        except:
+            session.error = T("Error encountered while applying the theme.")
+            redirect(URL(r=request, args=request.args))
+        os.chdir(currentdir)
+
+        # Don't do standard redirect to List view as we only want this option available
+        redirect(URL(r=request, args=[1, "update"]))
+    else:
+        session.error = INVALIDREQUEST
+        redirect(URL(r=request))
+
+
+# -----------------------------------------------------------------------------
+def theme_check(form):
+    "Check the Theme has valid files available. Deprecated"
+    # Check which form we're called by
+    if form.vars.theme:
+        # Called from Settings
+        theme = db(db.admin_theme.id == form.vars.theme).select(db.admin_theme.logo, limitby=(0, 1)).first()
+        logo = theme.logo
+        #header_background = theme.header_background
+        #footer = theme.footer
+    #elif form.vars.logo and form.vars.footer:
+    elif form.vars.logo:
+        # Called from Theme
+        logo = form.vars.logo
+        #header_background = form.vars.header_background
+        #footer = form.vars.footer
+    else:
+        session.error = INVALIDREQUEST
+        redirect(URL(r=request))
+
+    _logo = os.path.join(request.folder, "static", logo)
+    #_header_background = os.path.join(request.folder, "static", header_background)
+    #_footer = os.path.join(request.folder, "views", footer)
+    if not os.access(_logo, os.R_OK):
+        form.errors["logo"] = T("Logo file %s missing!" % logo)
+        return
+    #if not os.access(_header_background, os.R_OK):
+    #    form.errors["header_background"] = T("Header background file %s missing!" % logo)
+    #    return
+    #if not os.access(_footer, os.R_OK):
+    #    form.errors["footer"] = T("Footer file %s missing!" % footer)
+    #    return
+    # Validation passed
+    return
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def user():
+    """ RESTful CRUD controller """
+    module = "auth"
+    resource = "user"
+    tablename = module + "_" + resource
+    table = db[tablename]
+
+    # Model options
+    role_manager = s3base.S3RoleManager()
+    s3xrc.model.set_method(module, resource, method="roles", action=role_manager)
+
+    # CRUD Strings
+    ADD_USER = T("Add User")
+    LIST_USERS = T("List Users")
+    s3.crud_strings[tablename] = Storage(
+        title_create = ADD_USER,
+        title_display = T("User Details"),
+        title_list = LIST_USERS,
+        title_update = T("Edit User"),
+        title_search = T("Search Users"),
+        subtitle_create = T("Add New User"),
+        subtitle_list = T("Users"),
+        label_list_button = LIST_USERS,
+        label_create_button = ADD_USER,
+        label_delete_button = T("Delete User"),
+        msg_record_created = T("User added"),
+        msg_record_modified = T("User updated"),
+        msg_record_deleted = T("User deleted"),
+        msg_list_empty = T("No Users currently registered"))
+
+    # Allow the ability for admin to Disable logins
+    db.auth_user.registration_key.writable = True
+    db.auth_user.registration_key.readable = True
+    db.auth_user.registration_key.label = T("Disabled?")
+
+    # In Controller to allow registration to work with UUIDs - only manual edits need this setting
+    db.auth_user.registration_key.requires = IS_NULL_OR(IS_IN_SET(["disabled", "pending"]))
+
+    # Pre-processor
+    def user_prep(jr):
+        if jr.method == "delete" and jr.http=="GET":
+            if jr.id == jr.session.auth.user.id: # we're trying to delete ourself
+                request.get_vars.update({"user.id":str(jr.id)})
+                jr.id = None
+                s3xrc.model.configure(table,
+                                      delete_next = URL(r=request, c="default", f="user/logout"))
+                s3.crud.confirm_delete = T("You are attempting to delete your own account - are you sure you want to proceed?")
+
+        elif jr.method == "update":
+            # Send an email to user if their account is approved
+            # (=moved from 'pending' to 'blank'(i.e. enabled))
+            s3xrc.model.configure(table,
+                                  onvalidation = lambda form: user_approve(form))
+        return True
+    response.s3.prep = user_prep
+
+    s3xrc.model.configure(table,
+        main="first_name",
+        # Add users to Person Registry & 'Authenticated' role:
+        create_onaccept = lambda form: auth.s3_register(form),
+        create_onvalidation = lambda form: user_create_onvalidation(form))
+    output = s3_rest_controller(module, resource)
+
+    if response.s3.actions:
+        response.s3.actions.insert(1,
+                    dict(label=str(T("Roles")), _class="action-btn",
+                         url=str(URL(r=request, c="admin", f="user", args=["[id]", "roles"]))))
+    return output
+
+
+# -----------------------------------------------------------------------------
+def user_create_onvalidation (form):
+    if (form.request_vars.has_key("password_two") and \
+        form.request_vars.password != form.request_vars.password_two):
+        form.errors.password = T("Password fields don't match")
+    return True
+
+
+# -----------------------------------------------------------------------------
+def user_approve(form):
+    "Send an email to user if their account is approved (moved from 'pending' to 'blank'(i.e. enabled))"
+    if form.vars.registration_key:
+        # Now non-blank
+        return
+    else:
+        # Now blank - lookup old value
+        status = db(db.auth_user.id == request.vars.id).select(db.auth_user.registration_key, limitby=(0, 1)).first().registration_key
+        if status == "pending":
+            # Send email to user confirming that they are now able to login
+            if not auth.settings.mailer or \
+                   not auth.settings.mailer.send(to=form.vars.email,
+                        subject=s3.messages.confirmation_email_subject,
+                        message=s3.messages.confirmation_email):
+                    session.warning = auth.messages.unable_send_email
+                    return
+        else:
+            return
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def usergroup():
+    """
+        User update form with groups
+        - NB This is currently unused & has no custom view
+    """
+    user = request.vars.user
+
+    # redirect to the user list if user id is not given
+    if user is None:
+        redirect(URL(r=request, f="user"))
+        return
+
+    # gather common variables
+    data = {}
+    data["user_id"] = user
+    data["username"] = db.auth_user[user].first_name + " " + \
+                       db.auth_user[user].last_name
+    data["role"] = db.auth_group[user].role
+
+    # display the standard user details
+    record = db(db.auth_user.id == user).select().first()
+    db.auth_user.id.readable = False
+
+    # Let admin view and modify the registration key
+    db.auth_user.registration_key.writable = True
+    db.auth_user.registration_key.readable = True
+    db.auth_user.registration_key.label = T("Disabled?")
+    db.auth_user.registration_key.requires = IS_NULL_OR(IS_IN_SET(["disabled", "pending"]))
+
+    form = SQLFORM(db.auth_user, record, deletable=True)
+
+    # find all groups user belongs to
+    query = (db.auth_membership.user_id == user)
+    allgroups = db().select(db.auth_group.ALL)
+    user_membership = db(query).select(db.auth_membership.ALL)
+
+    # db.auth_group[row.group_id].role
+    #records = SQLTABLE(db(query).select(db.auth_membership.ALL))
+
+    # handle the M to M of user to group membership for display
+    records = []
+    for group in allgroups:
+
+        user_group_count = 0
+
+        for row in user_membership:
+
+            if (row.group_id == group.id):
+                records.append([group.role, "on", group.id])
+                user_group_count += 1
+
+        if (user_group_count == 0):
+            # if the group does not exist currently and is enabled
+            #if request.has_key(group.id):
+            if (group.id == 6):
+                db.auth_membership.insert(user_id = user, group_id = group.id)
+                records.append([group.role, "on", group.id])
+                data["heehe"] = "yes %d" % group.id
+
+            records.append([group.role, "", group.id])
+
+    # Update records for user details
+    if form.accepts(request.vars): \
+                    response.flash="User " + data["username"] + " Updated"
+    elif form.errors: \
+                    response.flash="There were errors in the form"
+
+    # Update records for group membership details
+    for key in request.vars.keys():
+        data["m_" + key] = request.vars[key]
+
+    return dict(data=data, records=records, form=form)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def group():
+
+    """ RESTful CRUD controller """
+
+    prefix = "auth"
+    resourcename = "group"
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    # Model options
+
+    # CRUD Strings
+    ADD_ROLE = T("Add Role")
+    LIST_ROLES = T("List Roles")
+    s3.crud_strings[tablename] = Storage(
+        title_create = ADD_ROLE,
+        title_display = T("Role Details"),
+        title_list = LIST_ROLES,
+        title_update = T("Edit Role"),
+        title_search = T("Search Roles"),
+        subtitle_create = T("Add New Role"),
+        subtitle_list = T("Roles"),
+        label_list_button = LIST_ROLES,
+        label_create_button = ADD_ROLE,
+        msg_record_created = T("Role added"),
+        msg_record_modified = T("Role updated"),
+        msg_record_deleted = T("Role deleted"),
+        msg_list_empty = T("No Roles currently defined"))
+
+    s3xrc.model.configure(table, main="role")
+    return s3_rest_controller(prefix, resourcename)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def membership():
+
+    """ RESTful CRUD controller """
+
+    prefix = "auth"
+    resourcename = "membership"
+    tablename = prefix + "_" + resourcename
+    table = db[tablename]
+
+    # Model options
+    db.auth_membership.group_id.represent = shn_role_represent
+    db.auth_membership.user_id.represent = shn_user_represent
+
+    # CRUD Strings
+    ADD_MEMBERSHIP = T("Add Membership")
+    LIST_MEMBERSHIPS = T("List Memberships")
+    s3.crud_strings[tablename] = Storage(
+        title_create = ADD_MEMBERSHIP,
+        title_display = T("Membership Details"),
+        title_list = LIST_MEMBERSHIPS,
+        title_update = T("Edit Membership"),
+        title_search = T("Search Memberships"),
+        subtitle_create = T("Add New Membership"),
+        subtitle_list = T("Memberships"),
+        label_list_button = LIST_MEMBERSHIPS,
+        label_create_button = ADD_MEMBERSHIP,
+        msg_record_created = T("Membership added"),
+        msg_record_modified = T("Membership updated"),
+        msg_record_deleted = T("Membership deleted"),
+        msg_list_empty = T("No Memberships currently defined"))
+
+    s3xrc.model.configure(table, main="user_id")
+    return s3_rest_controller(prefix, resourcename)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def users():
+    """
+    List/amend which users are in a Group
+
+    @deprecated
+
+    """
+
+    try:
+        group = int(request.args(0))
+    except TypeError, ValueError:
+        session.error = T("Need to specify a role!")
+        redirect(URL(r=request, f="group"))
+
+    table = db.auth_membership
+    query = table.group_id == group
+    title = T("Role") + ": " + db.auth_group[group].role
+    description = db.auth_group[group].description
+    # Start building the Return
+    output = dict(title=title, description=description, group=group)
+
+    if auth.settings.username:
+        username = "username"
+    else:
+        username = "email"
+
+    # Audit
+    crud.settings.create_onaccept = lambda form: s3_audit("create", module, "membership",
+                                                          form=form,
+                                                          representation="html")
+    crud.settings.create_onvalidation = lambda form: group_dupes(form, "users", [group])
+    # Many<>Many selection (Deletable, no Quantity)
+    item_list = []
+    sqlrows = db(query).select()
+    even = True
+    for row in sqlrows:
+        if even:
+            theclass = "even"
+            even = False
+        else:
+            theclass = "odd"
+            even = True
+        id = row.user_id
+        _user = db.auth_user[id]
+        item_first = _user.first_name
+        item_second = _user.last_name
+        item_description = _user[username]
+        id_link = A(id, _href=URL(r=request, f="user", args=[id, "read"]))
+        checkbox = INPUT(_type="checkbox", _value="on", _name=id, _class="remove_item")
+        item_list.append(TR(TD(id_link), TD(item_first), TD(item_second), TD(item_description), TD(checkbox), _class=theclass))
+
+    if auth.settings.username:
+        username_label = T("Username")
+    else:
+        username_label = T("Email")
+    table_header = THEAD(TR(TH("ID"), TH(T("First Name")), TH(T("Last Name")), TH(username_label), TH(T("Remove"))))
+    table_footer = TFOOT(TR(TD(_colspan=4), TD(INPUT(_id="submit_delete_button", _type="submit", _value=T("Remove")))))
+    items = DIV(FORM(
+        TABLE(table_header,
+              TBODY(item_list),
+              table_footer, _id="list", _class="display"), _name="custom", _method="post", _enctype="multipart/form-data", _action=URL(r=request, f="group_remove_users", args=[group])))
+
+    subtitle = T("Users")
+    crud.messages.submit_button = T("Add")
+    crud.messages.record_created = T("Role Updated")
+    form = crud.create(table, next=URL(r=request, args=[group]))
+    addtitle = T("Add New User to Role")
+    output.update(dict(subtitle=subtitle, items=items, addtitle=addtitle, form=form))
+    return output
+
+
+# -----------------------------------------------------------------------------
+def group_dupes(form, page, arg):
+    """
+    Onvalidation check for duplicate user roles
+
+    @deprecated
+
+    """
+
+    user = form.latest["user_id"]
+    group = form.latest["group_id"]
+    query = (form.table.user_id == user) & (form.table.group_id == group)
+    items = db(query).select()
+    if items:
+        session.error = T("User already has this role")
+        redirect(URL(r=request, f=page, args=arg))
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def group_remove_users():
+    """
+        Remove users from a group
+    """
+    if len(request.args) == 0:
+        session.error = T("Need to specify a group!")
+        redirect(URL(r=request, f="group"))
+    group = request.args(0)
+    table = db.auth_membership
+    for var in request.vars:
+        if str(var).isdigit():
+            user = var
+            query = (table.group_id == group) & (table.user_id == user)
+            db(query).delete()
+    # Audit
+    #crud.settings.update_onaccept = lambda form: shn_audit_update(form, "membership", "html")
+    session.flash = T("Users removed")
+    redirect(URL(r=request, f="users", args=[group]))
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def groups():
+    """
+        List/amend which groups a User is in
+    """
+
+    try:
+        user = int(request.args(0))
+    except TypeError, ValueError:
+        session.error = T("Need to specify a user!")
+        redirect(URL(r=request, f="user"))
+
+    table = db.auth_membership
+    query = table.user_id == user
+    title = db.auth_user[user].first_name + " " + db.auth_user[user].last_name
+    description = db.auth_user[user].email
+    # Start building the Return
+    output = dict(title=title, description=description, user=user)
+
+    # Audit
+    crud.settings.create_onaccept = lambda form: s3_audit("create", module, "membership",
+                                                          form=form,
+                                                          representation="html")
+
+
+    crud.settings.create_onvalidation = lambda form: group_dupes(form, "groups", [user])
+    # Many<>Many selection (Deletable, no Quantity)
+    item_list = []
+    sqlrows = db(query).select()
+    even = True
+    for row in sqlrows:
+        if even:
+            theclass = "even"
+            even = False
+        else:
+            theclass = "odd"
+            even = True
+        id = row.group_id
+        _group = db.auth_group[id]
+        item_first = _group.role
+        item_description = _group.description
+        id_link = A(id, _href=URL(r=request, f="group", args=[id, "read"]))
+        checkbox = INPUT(_type="checkbox", _value="on", _name=id, _class="remove_item")
+        item_list.append(TR(TD(id_link), TD(item_first), TD(item_description), TD(checkbox), _class=theclass))
+
+    table_header = THEAD(TR(TH("ID"), TH(T("Role")), TH(T("Description")), TH(T("Remove"))))
+    table_footer = TFOOT(TR(TD(_colspan=3), TD(INPUT(_id="submit_delete_button", _type="submit", _value=T("Remove")))))
+    items = DIV(FORM(TABLE(table_header, TBODY(item_list), table_footer, _id="table-container"), _name="custom", _method="post", _enctype="multipart/form-data", _action=URL(r=request, f="user_remove_groups", args=[user])))
+
+    subtitle = T("Roles")
+    crud.messages.submit_button = T("Add")
+    crud.messages.record_created = T("User Updated")
+    form = crud.create(table, next=URL(r=request, args=[user]))
+    addtitle = T("Add New Role to User")
+    output.update(dict(subtitle=subtitle, items=items, addtitle=addtitle, form=form))
+    return output
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def user_remove_groups():
+    """ Remove groups from a user """
+    if len(request.args) == 0:
+        session.error = T("Need to specify a user!")
+        redirect(URL(r=request, f="user"))
+    user = request.args(0)
+    table = db.auth_membership
+    for var in request.vars:
+        if str(var).isdigit():
+            group = var
+            query = (table.group_id == group) & (table.user_id == user)
+            db(query).delete()
+    # Audit
+    #crud.settings.update_onaccept = lambda form: shn_audit_update(form, "membership", "html")
+    session.flash = T("Groups removed")
+    redirect(URL(r=request, f="groups", args=[user]))
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def import_data():
+    """
+        Import data via POST upload to CRUD controller. Old - being replaced by Sync/Importer.
+    """
+    title = T("Import Data")
+    crud.messages.submit_button = "Upload"
+
+    # Deprecated
+    import_job_form = crud.create(db.admin_import_job)
+    # Tell the CRUD create form to post to a different location
+    import_job_form.custom.begin.text = str(import_job_form.custom.begin).replace(
+            'action=""',
+            'action="%s"' % URL(r=request, f="import_job", args=["create"]))
+
+    return dict(title=title,
+                import_job_form=import_job_form)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def import_csv_data():
+    """
+        Import CSV data via POST upload to Database.
+    """
+    file = request.vars.multifile.file
+    try:
+        # Assumes that it is a concatenation of tables
+        import_csv(file)
+        session.flash = T("Data uploaded")
+    except Exception, e:
+        session.error = T("Unable to parse CSV file!")
+    redirect(URL(r=request, f="import_data"))
+
+
+# -----------------------------------------------------------------------------
[e-mail]_login()
+def export_data():
+    """
+        Export data via CRUD controller. Old - being replaced by Sync.
+    """
+    title = T("Export Data")
+    return dict(title=title)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def export_csv():
+    """
+        Export entire database as CSV. Old - being replaced by Sync.
+    """
+    import StringIO
+    output = StringIO.StringIO()
+
+    db.export_to_csv_file(output)
+
+    output.seek(0)
+    import gluon.contenttype
+    response.headers["Content-Type"] = gluon.contenttype.contenttype(".csv")
+    filename = "%s_database.csv" % (request.env.server_name)
+    response.headers["Content-disposition"] = "attachment; filename=%s" % filename
+    return output.read()
+
+
+# -----------------------------------------------------------------------------
+# Unstructured Data Import
+# Deprecated - being replaced by Importer
+@auth.s3_requires_membership(1)
+def import_job():
+    "RESTful CRUD controller to handle 'jobs' for importing unstructured data."
+    # CRUD Strings
+    module = "admin"
+    resource = "import_job"
+    table = "%s_%s" % (module, resource)
+    # This breaks!
+    jr = s3xrc.request(module, resource, request, session=session)
+    CREATE_NEW_IMPORT_JOB = T("Create New Import Job")
+    LIST_IMPORT_JOBS = ("List Import Jobs")
+    s3.crud_strings[table] = Storage(
+            title_create=CREATE_NEW_IMPORT_JOB,
+            title_display=T("Import Job"),
+            title_list=LIST_IMPORT_JOBS,
+            title_update=T("Update Import Job"),
+            subtitle_create=CREATE_NEW_IMPORT_JOB,
+            subtitle_list=T("Import Jobs"),
+            label_list_button=LIST_IMPORT_JOBS,
+            label_create_button=T("Create Import Job"),
+            msg_record_created=T("Import job created"),
+            msg_list_empty=T("No import jobs")
+    )
+
+    if len(request.args) == 0:
+        return _import_job_list(jr)
+    action = request.args(0)
+    if action == "create":
+        return _import_job_create(jr)
+    if action == "update":
+        return _import_job_update(jr)
+
+
+# -----------------------------------------------------------------------------
+def _import_job_list(jr):
+    return shn_list(jr, listadd=False)
+
+
+# -----------------------------------------------------------------------------
+def _import_job_create(jr):
+    if jr.http != "POST":
+        redirect(jr.there())
+
+    def process_new_file_and_redirect(form):
+        filename = form.vars.source_file_newfilename
+        filepath = os.path.join(request.folder, "uploads", filename)
+        query = (jr.table.id == form.vars.id)
+        column_map = []
+        model_fields = dict(map(
+                lambda x:(x.lower(), x),
+                get_matchable_fields(form.vars.module, form.vars.resource)))
+        try:
+            reader = csv.reader(open(filepath, "r"))
+            for line in reader:
+                for col in line:
+                    field = None
+                    col_match = col.lower()
+                    if col_match in model_fields:
+                        # Explicit name match.
+                        field = model_fields.pop(col_match)
+                    if not field:
+                        # Partial name patch.
+                        for field_name in model_fields:
+                            if col_match in field_name or field_name in col_match:
+                                field = model_fields.pop(field_name)
+                                break
+                    column_map.append((col, field))
+                break
+            pickled_map = pickle.dumps(column_map, pickle.HIGHEST_PROTOCOL)
+            db(query).update(column_map=pickled_map)
+        except:
+            db(query).update(status="failed")
+        redirect(URL(r=request, f="import_job", args=[form.vars.id, "update"]))
+
+    form = crud.create(jr.table, onaccept=process_new_file_and_redirect)
+    response.flash = "Form errors!"
+    redirect(URL(r=request, f="import_data"))
+
+
+# -----------------------------------------------------------------------------
+def _import_job_update(jr):
+    if len(request.args) < 2:
+        redirect(jr.there())
+    id = request.args[1]
+    query = (jr.table.id == id)
+    job = db(query).select()
+    if not job:
+        raise HTTP(404, body=s3xrc.xml.json_message(False, 404, session.error))
+    job = job[0]
+
+    if jr.http == "GET":
+        output = _import_job_update_GET(jr, job)
+    elif jr.http == "POST":
+        output = _import_job_update_POST(jr, job)
+    else:
+        raise HTTP(400, body=INVALIDREQUEST)
+
+    title = "%s - %s" % (T("Input Job"), job.description)
+    output.update(dict(title=title, job=job))
+    response.view = "admin/import_job_update.html"
+    return output
+
+
+# -----------------------------------------------------------------------------
+def _import_job_update_GET(jr, job):
+    table = db.admin_import_line
+    query = (table.import_job == job.id)
+
+    if job.status == "new":
+        try:
+            job.column_map = pickle.loads(job.column_map)
+        except pickle.UnpicklingError:
+            job.column_map = []
+        model_fields = get_matchable_fields(job.module, job.resource)
+        return dict(model_fields=model_fields)
+
+    if job.status == "processing":
+        num_lines = db(query).count()
+        return dict(num_lines=num_lines, update_speed=60)
+
+    if job.status in ["processed", "failed", "imported"]:
+        def _include_field(f):
+            if f in ["import_job"]:
+                return False
+            return table[f].readable
+
+        fields = [table[f] for f in table.fields if _include_field(f)]
+        headers = dict(map(lambda f: (str(f), f.label), fields))
+        items = crud.select(
+                db["admin_import_line"],
+                query=query,
+                fields=fields,
+                headers=headers,
+                truncate=48, _id="list", _class="display")
+        response.extra_styles = ["admin/import_job.css"]
+        return dict(items=items)
+
+    if job.status == "import":
+        query = (table.import_job == job.id) & (table.status == "imported")
+        num_lines = db(query).count()
+        return dict(num_lines=num_lines, update_speed=60)
+
+    return {}
+
+
+# -----------------------------------------------------------------------------
+def _import_job_update_POST(jr, job):
+    if job.status == "new":
+        # Update column map.
+        try:
+            column_map = pickle.loads(job.column_map)
+        except pickle.UnpicklingError:
+            column_map = []
+        for key, value in request.vars.iteritems():
+            if not key.startswith("column_map_"):
+                continue
+            try:
+                idx = int(key.split("_")[-1])
+            except ValueError:
+                continue
+            if value != "None (Ignore)":
+                column_map[idx] = (column_map[idx][0], value)
+            else:
+                column_map[idx] = (column_map[idx][0], None)
+        jr.table[job.id] = dict(
+                column_map=pickle.dumps(column_map, pickle.HIGHEST_PROTOCOL),
+                status="processing")
+        job.status = "processing"
+
+    if job.status == "processed":
+        query = db.admin_import_line.id
+        for var, status in request.vars.iteritems():
+            if not var.startswith("status_"):
+                continue
+            try:
+                import_line_id = int(var.split("_")[-1])
+            except ValueError:
+                continue
+            db(db.admin_import_line.id == import_line_id).update(status=status)
+        jr.table[job.id] = dict(status="import")
+        job.status = "import"
+
+    return _import_job_update_GET(jr, job)
+
+
+# -----------------------------------------------------------------------------
+def get_matchable_fields(module, resource):
+    model_fields = getattr(db, "%s_%s" % (module, resource)).fields
+    for name in ["created_on", "modified_on", "id", "uuid", "deleted"]:
+        model_fields.remove(name)
+    model_fields.insert(0, "None (Ignore)")
+    return model_fields
+
+
+
+# -----------------------------------------------------------------------------
+# Functional Testing
+# Deprecated: Use static/selenium/scripts/regressionTests.py with it's Tk UI
+def handleResults():
+    """
+        Process the POST data returned from Selenium TestRunner.
+        The data is written out to 2 files.  The overall results are written to
+        date-time-browserName-metadata.txt as a list of key: value, one per line.  The
+        suiteTable and testTables are written to date-time-browserName-results.html.
+    """
+
+    if not request.vars.result:
+        # No results
+        return
+
+    # Read in results
+    result = request.vars.result
+    totalTime = request.vars.totalTime
+    numberOfSuccesses = request.vars.numTestPasses
+    numberOfFailures = request.vars.numTestFailures
+    numberOfCommandSuccesses = request.vars.numCommandPasses
+    numberOfCommandFailures = request.vars.numCommandFailures
+    numberOfCommandErrors = request.vars.numCommandErrors
+
+    suiteTable = ""
+    if request.vars.suite:
+        suiteTable = request.vars.suite
+
+    testTables = []
+    testTableNum = 1
+    while request.vars["testTable.%s" % testTableNum]:
+        testTable = request.vars["testTable.%s" % testTableNum]
+        testTables.append(testTable)
+        testTableNum += 1
+        try:
+            request.vars["testTable.%s" % testTableNum]
+            pass
+        except:
+            break
+
+    # Unescape the HTML tables
+    import urllib
+    suiteTable = urllib.unquote(suiteTable)
+    testTables = map(urllib.unquote, testTables)
+
+    # We want to store results separately for each browser
+    browserName = getBrowserName(request.env.http_user_agent)
+    date = str(request.utcnow)[:-16]
+    time = str(request.utcnow)[11:-10]
+    time = time.replace(":", "-")
+
+    # Write out results
+    outputDir = os.path.join(request.folder, "static", "selenium", "results")
+    metadataFile = "%s-%s-%s-metadata.txt" % (date, time, browserName)
+    dataFile = "%s-%s-%s-results.html" % (date, time, browserName)
+
+    #xmlText = '<selenium result="' + result + '" totalTime="' + totalTime + '" successes="' + numberOfCommandSuccesses + '" failures="' + numberOfCommandFailures + '" errors="' + numberOfCommandErrors + '" />'
+    f = open(os.path.join(outputDir, metadataFile), "w")
+    for key in request.vars.keys():
+        if "testTable" in key or key in ["log", "suite"]:
+            pass
+        else:
+            print >> f, "%s: %s" % (key, request.vars[key])
+    f.close()
+
+    f = open(os.path.join(outputDir, dataFile), "w")
+    print >> f, suiteTable
+    for testTable in testTables:
+        print >> f, "<br/><br/>"
+        print >> f, testTable
+    f.close()
+
+    message = DIV(P("Results have been successfully posted to the server here:"),
+        P(A(metadataFile, _href=URL(r=request, c="static", f="selenium", args=["results", metadataFile]))),
+        P(A(dataFile, _href=URL(r=request, c="static", f="selenium", args=["results", dataFile]))))
+
+    response.view = "display.html"
+    title = T("Test Results")
+    return dict(title=title, item=message)
+
+
+# -----------------------------------------------------------------------------
+# Ticket Viewer functions Borrowed from admin application of web2py
+@auth.s3_requires_membership(1)
+def errors():
+    """ Error handler """
+
+    app = request.application
+
+    for item in request.vars:
+        if item[:7] == "delete_":
+            os.unlink(apath("%s/errors/%s" % (app, item[7:]), r=request))
+
+    func = lambda p: os.stat(apath("%s/errors/%s" % (app, p), r=request)).st_mtime
+    tickets = sorted(listdir(apath("%s/errors/" % app, r=request), "^\w.*"),
+                     key=func,
+                     reverse=True)
+
+    return dict(app=app, tickets=tickets)
+
+
+# -----------------------------------------------------------------------------
+def make_link(path):
+    """ Create a link from a path """
+    tryFile = path.replace("\\", "/")
+
+    if os.path.isabs(tryFile) and os.path.isfile(tryFile):
+        (folder, filename) = os.path.split(tryFile)
+        (base, ext) = os.path.splitext(filename)
+        app = request.args[0]
+
+        editable = {"controllers": ".py", "models": ".py", "views": ".html"}
+        for key in editable.keys():
+            check_extension = folder.endswith("%s/%s" % (app, key))
+            if ext.lower() == editable[key] and check_extension:
+                return A('"' + tryFile + '"',
+                         _href=URL(r=request,
+                         f="edit/%s/%s/%s" % (app, key, filename))).xml()
+    return ""
+
+
+# -----------------------------------------------------------------------------
+def make_links(traceback):
+    """ Make links using the given traceback """
+
+    lwords = traceback.split('"')
+
+    # Make the short circuit compatible with <= python2.4
+    result = (len(lwords) != 0) and lwords[0] or ""
+
+    i = 1
+
+    while i < len(lwords):
+        link = make_link(lwords[i])
+
+        if link == "":
+            result += '"' + lwords[i]
+        else:
+            result += link
+
+            if i + 1 < len(lwords):
+                result += lwords[i + 1]
+                i = i + 1
+
+        i = i + 1
+
+    return result
+
+
+# -----------------------------------------------------------------------------
+class TRACEBACK(object):
+    """ Generate the traceback """
+
+    def __init__(self, text):
+        """ TRACEBACK constructor """
+
+        self.s = make_links(CODE(text).xml())
+
+    def xml(self):
+        """ Returns the xml """
+
+        return self.s
+
+
+# -----------------------------------------------------------------------------
+# Ticket viewing
+@auth.s3_requires_membership(1)
+def ticket():
+    """ Ticket handler """
+
+    if len(request.args) != 2:
+        session.flash = T("Invalid ticket")
+        redirect(URL(r=request))
+
+    app = request.args[0]
+    ticket = request.args[1]
+    e = RestrictedError()
+    e.load(request, app, ticket)
+
+    return dict(app=app,
+                ticket=ticket,
+                traceback=TRACEBACK(e.traceback),
+                code=e.code,
+                layer=e.layer)
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def role():
+    """
+    Role Manager
+
+    @author: Dominic König <[e-mail]>
+
+    """
+
+    prefix = "auth"
+    name = "group"
+
+    # ACLs as component of roles
+    s3xrc.model.add_component("s3", "permission",
+        joinby = dict(auth_group="group_id"),
+        multiple=True)
+
+    def prep(r):
+        if r.representation not in ("html",):
+            return False
+
+        handler = s3base.S3RoleManager()
+        modules = deployment_settings.modules
+        handler.controllers = Storage([(m, modules[m]) for m in modules
+                                                       if modules[m].restricted])
+
+        # Configure REST methods
+        resource = r.resource
+        resource.add_method("users", handler)
+        resource.set_handler("read", handler)
+        resource.set_handler("list", handler)
+        resource.set_handler("copy", handler)
+        resource.set_handler("create", handler)
+        resource.set_handler("update", handler)
+        resource.set_handler("delete", handler)
+        return True
+    response.s3.prep = prep
+
+    response.s3.no_sspag = True
+    response.extra_styles = ["S3/role.css"]
+
+    output = s3_rest_controller(prefix, name)
+    return output
+
+
+# -----------------------------------------------------------------------------
+@auth.s3_requires_membership(1)
+def acl():
+    """
+    Preliminary controller for ACLs
+    for testing purposes, not for production use!
+
+    """
+
+    prefix = "s3"
+    name = "permission"
+
+    table = auth.permission.table
+    table.group_id.requires = IS_ONE_OF(db, "auth_group.id", "%(role)s")
+    table.group_id.represent = lambda opt: opt and db.auth_group[opt].role or opt
+
+    table.controller.requires = IS_EMPTY_OR(IS_IN_SET(auth.permission.modules.keys(), zero="ANY"))
+    table.controller.represent = lambda opt: opt and "%s (%s)" % (opt, auth.permission.modules.get(opt, {}).get("name_nice", opt)) or "ANY"
+
+    table.function.represent = lambda val: val and val or T("ANY")
+
+    table.tablename.requires = IS_EMPTY_OR(IS_IN_SET([t._tablename for t in db], zero=T("ANY")))
+    table.tablename.represent = lambda val: val and val or T("ANY")
+
+    table.uacl.label = T("All Resources")
+    table.uacl.widget = S3ACLWidget.widget
+    table.uacl.requires = IS_ACL(auth.permission.PERMISSION_OPTS)
+    table.uacl.represent = lambda val: acl_represent(val, auth.permission.PERMISSION_OPTS)
+
+    table.oacl.label = T("Owned Resources")
+    table.oacl.widget = S3ACLWidget.widget
+    table.oacl.requires = IS_ACL(auth.permission.PERMISSION_OPTS)
+    table.oacl.represent = lambda val: acl_represent(val, auth.permission.PERMISSION_OPTS)
+
+    s3xrc.model.configure(table,
+        create_next = URL(r=request),
+        update_next = URL(r=request))
+
+    output = s3_rest_controller(prefix, name)
+    return output
+
+
+# -----------------------------------------------------------------------------
+def acl_represent(acl, options):
+    """
+    Represent ACLs in tables
+    for testing purposes, not for production use!
+
+    """
+
+    values = []
+
+    for o in options.keys():
+        if o == 0 and acl == 0:
+            values.append("%s" % options[o][0])
+        elif acl and acl & o == o:
+            values.append("%s" % options[o][0])
+        else:
+            values.append("_")
+
+    return " ".join(values)
+
+# -----------------------------------------------------------------------------

=== removed file 'controllers/admin.py'
--- controllers/admin.py	2011-01-12 00:45:29 +0000
+++ controllers/admin.py	1970-01-01 00:00:00 +0000
@@ -1,1241 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    Admin Controllers
-"""
-
-import cPickle as pickle
-import csv
-from gluon.admin import *
-from gluon.fileutils import listdir
-
-module = "admin"
-
-# Options Menu (available in all Functions' Views)
-# - can Insert/Delete items from default menus within a function, if required.
-response.menu_options = admin_menu_options
-
-# S3 framework functions
-# -----------------------------------------------------------------------------
-def index():
-
-    """ Module's Home Page """
-
-    module_name = deployment_settings.modules[module].name_nice
-    response.title = module_name
-    return dict(module_name=module_name)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def setting():
-
-    """ RESTful CRUD controller """
-
-    resourcename = request.function
-    tablename = "s3_" + resourcename
-    table = db[tablename]
-
-    table.admin_name.label = T("Admin Name")
-    table.admin_email.label = T("Admin Email")
-    table.admin_tel.label = T("Admin Tel")
-    #table.utc_offset.label = T("UTC Offset")
-    table.theme.label = T("Theme")
-    table.theme.comment = DIV(A(T("Add Theme"), _class="colorbox", _href=URL(r=request, c="admin", f="theme", args="create", vars=dict(format="popup")), _target="top", _title=T("Add Theme"))),
-    #table.archive_not_delete.label = T("Archive not Delete")
-    #table.archive_not_delete.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Archive not Delete") + "|" + T("If this setting is enabled then all deleted records are just flagged as deleted instead of being really deleted. They will appear in the raw database access but won't be visible to normal users."))
-    #table.debug.label = T("Debug")
-    #table.debug.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Debug") + "|" + T("Switch this on to use individual CSS/Javascript files for diagnostics during development."))
-    #table.self_registration.label = T("Self Registration")
-    #table.self_registration.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Self-registration") + "|" + T("Can users register themselves for authenticated login access?"))
-    #table.security_policy.label = T("Security Policy")
-    #table.security_policy.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Security Policy") + "|" + T("The simple policy allows anonymous users to Read & registered users to Edit. The full security policy allows the administrator to set permissions on individual tables or records - see models/zzz.py."))
-    #table.audit_read.label = T("Audit Read")
-    #table.audit_read.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Audit Read") + "|" + T("If enabled then a log is maintained of all records a user accesses. If disabled then it can still be enabled on a per-module basis."))
-    #table.audit_write.label = T("Audit Write")
-    #table.audit_write.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Audit Write") + "|" + T("If enabled then a log is maintained of all records a user edits. If disabled then it can still be enabled on a per-module basis."))
-
-    s3.crud_strings[tablename] = Storage(
-        title_update = T("Edit Settings"),
-        msg_record_modified = T("Settings updated"),
-        label_list_button = None)
-
-    s3xrc.model.configure(table,
-                          deletable=False,
-                          listadd=False,
-                          #onvalidation=theme_check,
-                          #update_next = URL(r=request, args=[1, "update"])
-                          onaccept=theme_apply)
-
-    output = s3_rest_controller("s3", resourcename, list_btn=None)
-    return output
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def theme():
-    """ RESTful CRUD controller """
-    resource = "theme"
-    tablename = module + "_" + resource
-    table = db[tablename]
-
-    # Model options
-    table.name.label = T("Name")
-    #table.logo.label = T("Logo")
-    #table.logo.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Logo") + "|" + T("Name of the file (& optional sub-path) located in static which should be used for the top-left image."))
-    #table.header_background.label = T("Header Background")
-    #table.header_background.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Header Background") + "|" + T("Name of the file (& optional sub-path) located in static which should be used for the background of the header."))
-    #table.footer.label = T("Footer")
-    #table.footer.comment = A(SPAN("[Help]"), _class="tooltip", _title=T("Footer") + "|" + T("Name of the file (& optional sub-path) located in views which should be used for footer."))
-    table.col_background.label = T("Background Colour")
-    table.col_txt.label = T("Text Colour for Text blocks")
-    table.col_txt_background.label = T("Background Colour for Text blocks")
-    table.col_txt_border.label = T("Border Colour for Text blocks")
-    table.col_txt_underline.label = T("Colour for Underline of Subheadings")
-    table.col_menu.label = T("Colour of dropdown menus")
-    table.col_highlight.label = T("Colour of selected menu items")
-    table.col_input.label = T("Colour of selected Input fields")
-    table.col_border_btn_out.label = T("Colour of bottom of Buttons when not pressed")
-    table.col_border_btn_in.label = T("Colour of bottom of Buttons when pressed")
-    table.col_btn_hover.label = T("Colour of Buttons when hovering")
-
-    # CRUD Strings
-    ADD_THEME = T("Add Theme")
-    LIST_THEMES = T("List Themes")
-    s3.crud_strings[resource] = Storage(
-        title_create = ADD_THEME,
-        title_display = T("Theme Details"),
-        title_list = LIST_THEMES,
-        title_update = T("Edit Theme"),
-        title_search = T("Search Themes"),
-        subtitle_create = T("Add New Theme"),
-        subtitle_list = T("Themes"),
-        label_list_button = LIST_THEMES,
-        label_create_button = ADD_THEME,
-        msg_record_created = T("Theme added"),
-        msg_record_modified = T("Theme updated"),
-        msg_record_deleted = T("Theme deleted"),
-        msg_list_empty = T("No Themes currently defined"))
-
-    s3xrc.model.configure(table,
-                          #onvalidation=theme_check,
-                          #list_fields=["id", "name", "logo", "footer", "col_background"],
-                          list_fields=["id", "name", "col_background"],
-                          )
-
-    return s3_rest_controller(module, resource)
-    s3xrc.model.clear_config(table, "onvalidation")
-
-
-# -----------------------------------------------------------------------------
-def theme_apply(form):
-    "Apply the Theme specified by Form"
-    if form.vars.theme:
-        # Valid form
-        # Relevant paths
-        template = os.path.join(request.folder, "static", "styles", "S3", "template.css")
-        tmp_folder = os.path.join(request.folder, "static", "scripts", "tools")
-        out_file = os.path.join(request.folder, "static", "styles", "S3", "sahana.css")
-        out_file2 = os.path.join(request.folder, "static", "styles", "S3", "sahana.min.css")
-        # Check permissions
-        if not os.access(template, os.R_OK):
-            session.error = T("Template file %s not readable - unable to apply theme!" % template)
-            redirect(URL(r=request, args=request.args))
-        if not os.access(tmp_folder, os.W_OK):
-            session.error = T("Temp folder %s not writable - unable to apply theme!" % tmp_folder)
-            redirect(URL(r=request, args=request.args))
-        if not os.access(out_file, os.W_OK):
-            session.error = T("CSS file %s not writable - unable to apply theme!" % out_file)
-            redirect(URL(r=request, args=request.args))
-        if not os.access(out_file2, os.W_OK):
-            session.error = T("CSS file %s not writable - unable to apply theme!" % out_file2)
-            redirect(URL(r=request, args=request.args))
-        # Read in Template
-        inpfile = open(template, "r")
-        lines = inpfile.readlines()
-        inpfile.close()
-        # Read settings from Database
-        theme = db(db.admin_theme.id == form.vars.theme).select(limitby=(0, 1)).first()
-        default_theme = db(db.admin_theme.id == 1).select(limitby=(0, 1)).first()
-        #if theme.logo:
-        #    logo = theme.logo
-        #else:
-        #    logo = default_theme.logo
-        #if theme.header_background:
-        #    header_background = theme.header_background
-        #else:
-        #    header_background = default_theme.header_background
-        # Write out CSS
-        ofile = open(out_file, "w")
-        for line in lines:
-            #line = line.replace("YOURLOGOHERE", logo)
-            #line = line.replace("HEADERBACKGROUND", header_background )
-            # Iterate through Colours
-            for key in theme.keys():
-                if key[:4] == "col_":
-                    if theme[key]:
-                        line = line.replace(key, theme[key])
-                    else:
-                        line = line.replace(key, default_theme[key])
-            ofile.write(line)
-        ofile.close()
-
-        # Minify
-        from subprocess import PIPE, check_call
-        currentdir = os.getcwd()
-        os.chdir(os.path.join(currentdir, request.folder, "static", "scripts", "tools"))
-        import sys
-        # If started as a Windows service, os.sys.executable is no longer python
-        if ("win" in sys.platform):
-            pythonpath = os.path.join(sys.prefix, "python.exe")
-        else:
-            pythonpath = os.sys.executable
-        try:
-            proc = check_call([pythonpath, "build.sahana.py", "CSS", "NOGIS"], stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=False)
-        except:
-            session.error = T("Error encountered while applying the theme.")
-            redirect(URL(r=request, args=request.args))
-        os.chdir(currentdir)
-
-        # Don't do standard redirect to List view as we only want this option available
-        redirect(URL(r=request, args=[1, "update"]))
-    else:
-        session.error = INVALIDREQUEST
-        redirect(URL(r=request))
-
-
-# -----------------------------------------------------------------------------
-def theme_check(form):
-    "Check the Theme has valid files available. Deprecated"
-    # Check which form we're called by
-    if form.vars.theme:
-        # Called from Settings
-        theme = db(db.admin_theme.id == form.vars.theme).select(db.admin_theme.logo, limitby=(0, 1)).first()
-        logo = theme.logo
-        #header_background = theme.header_background
-        #footer = theme.footer
-    #elif form.vars.logo and form.vars.footer:
-    elif form.vars.logo:
-        # Called from Theme
-        logo = form.vars.logo
-        #header_background = form.vars.header_background
-        #footer = form.vars.footer
-    else:
-        session.error = INVALIDREQUEST
-        redirect(URL(r=request))
-
-    _logo = os.path.join(request.folder, "static", logo)
-    #_header_background = os.path.join(request.folder, "static", header_background)
-    #_footer = os.path.join(request.folder, "views", footer)
-    if not os.access(_logo, os.R_OK):
-        form.errors["logo"] = T("Logo file %s missing!" % logo)
-        return
-    #if not os.access(_header_background, os.R_OK):
-    #    form.errors["header_background"] = T("Header background file %s missing!" % logo)
-    #    return
-    #if not os.access(_footer, os.R_OK):
-    #    form.errors["footer"] = T("Footer file %s missing!" % footer)
-    #    return
-    # Validation passed
-    return
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def user():
-    """ RESTful CRUD controller """
-    module = "auth"
-    resource = "user"
-    tablename = module + "_" + resource
-    table = db[tablename]
-
-    # Model options
-    role_manager = s3base.S3RoleManager()
-    s3xrc.model.set_method(module, resource, method="roles", action=role_manager)
-
-    # CRUD Strings
-    ADD_USER = T("Add User")
-    LIST_USERS = T("List Users")
-    s3.crud_strings[tablename] = Storage(
-        title_create = ADD_USER,
-        title_display = T("User Details"),
-        title_list = LIST_USERS,
-        title_update = T("Edit User"),
-        title_search = T("Search Users"),
-        subtitle_create = T("Add New User"),
-        subtitle_list = T("Users"),
-        label_list_button = LIST_USERS,
-        label_create_button = ADD_USER,
-        label_delete_button = T("Delete User"),
-        msg_record_created = T("User added"),
-        msg_record_modified = T("User updated"),
-        msg_record_deleted = T("User deleted"),
-        msg_list_empty = T("No Users currently registered"))
-
-    # Allow the ability for admin to Disable logins
-    db.auth_user.registration_key.writable = True
-    db.auth_user.registration_key.readable = True
-    db.auth_user.registration_key.label = T("Disabled?")
-
-    # In Controller to allow registration to work with UUIDs - only manual edits need this setting
-    db.auth_user.registration_key.requires = IS_NULL_OR(IS_IN_SET(["disabled", "pending"]))
-
-    # Pre-processor
-    def user_prep(jr):
-        if jr.method == "delete" and jr.http=="GET":
-            if jr.id == jr.session.auth.user.id: # we're trying to delete ourself
-                request.get_vars.update({"user.id":str(jr.id)})
-                jr.id = None
-                s3xrc.model.configure(table,
-                                      delete_next = URL(r=request, c="default", f="user/logout"))
-                s3.crud.confirm_delete = T("You are attempting to delete your own account - are you sure you want to proceed?")
-
-        elif jr.method == "update":
-            # Send an email to user if their account is approved
-            # (=moved from 'pending' to 'blank'(i.e. enabled))
-            s3xrc.model.configure(table,
-                                  onvalidation = lambda form: user_approve(form))
-        return True
-    response.s3.prep = user_prep
-
-    s3xrc.model.configure(table,
-        main="first_name",
-        # Add users to Person Registry & 'Authenticated' role:
-        create_onaccept = lambda form: auth.s3_register(form),
-        create_onvalidation = lambda form: user_create_onvalidation(form))
-    output = s3_rest_controller(module, resource)
-
-    if response.s3.actions:
-        response.s3.actions.insert(1,
-                    dict(label=str(T("Roles")), _class="action-btn",
-                         url=str(URL(r=request, c="admin", f="user", args=["[id]", "roles"]))))
-    return output
-
-
-# -----------------------------------------------------------------------------
-def user_create_onvalidation (form):
-    if (form.request_vars.has_key("password_two") and \
-        form.request_vars.password != form.request_vars.password_two):
-        form.errors.password = T("Password fields don't match")
-    return True
-
-
-# -----------------------------------------------------------------------------
-def user_approve(form):
-    "Send an email to user if their account is approved (moved from 'pending' to 'blank'(i.e. enabled))"
-    if form.vars.registration_key:
-        # Now non-blank
-        return
-    else:
-        # Now blank - lookup old value
-        status = db(db.auth_user.id == request.vars.id).select(db.auth_user.registration_key, limitby=(0, 1)).first().registration_key
-        if status == "pending":
-            # Send email to user confirming that they are now able to login
-            if not auth.settings.mailer or \
-                   not auth.settings.mailer.send(to=form.vars.email,
-                        subject=s3.messages.confirmation_email_subject,
-                        message=s3.messages.confirmation_email):
-                    session.warning = auth.messages.unable_send_email
-                    return
-        else:
-            return
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def usergroup():
-    """
-        User update form with groups
-        - NB This is currently unused & has no custom view
-    """
-    user = request.vars.user
-
-    # redirect to the user list if user id is not given
-    if user is None:
-        redirect(URL(r=request, f="user"))
-        return
-
-    # gather common variables
-    data = {}
-    data["user_id"] = user
-    data["username"] = db.auth_user[user].first_name + " " + \
-                       db.auth_user[user].last_name
-    data["role"] = db.auth_group[user].role
-
-    # display the standard user details
-    record = db(db.auth_user.id == user).select().first()
-    db.auth_user.id.readable = False
-
-    # Let admin view and modify the registration key
-    db.auth_user.registration_key.writable = True
-    db.auth_user.registration_key.readable = True
-    db.auth_user.registration_key.label = T("Disabled?")
-    db.auth_user.registration_key.requires = IS_NULL_OR(IS_IN_SET(["disabled", "pending"]))
-
-    form = SQLFORM(db.auth_user, record, deletable=True)
-
-    # find all groups user belongs to
-    query = (db.auth_membership.user_id == user)
-    allgroups = db().select(db.auth_group.ALL)
-    user_membership = db(query).select(db.auth_membership.ALL)
-
-    # db.auth_group[row.group_id].role
-    #records = SQLTABLE(db(query).select(db.auth_membership.ALL))
-
-    # handle the M to M of user to group membership for display
-    records = []
-    for group in allgroups:
-
-        user_group_count = 0
-
-        for row in user_membership:
-
-            if (row.group_id == group.id):
-                records.append([group.role, "on", group.id])
-                user_group_count += 1
-
-        if (user_group_count == 0):
-            # if the group does not exist currently and is enabled
-            #if request.has_key(group.id):
-            if (group.id == 6):
-                db.auth_membership.insert(user_id = user, group_id = group.id)
-                records.append([group.role, "on", group.id])
-                data["heehe"] = "yes %d" % group.id
-
-            records.append([group.role, "", group.id])
-
-    # Update records for user details
-    if form.accepts(request.vars): \
-                    response.flash="User " + data["username"] + " Updated"
-    elif form.errors: \
-                    response.flash="There were errors in the form"
-
-    # Update records for group membership details
-    for key in request.vars.keys():
-        data["m_" + key] = request.vars[key]
-
-    return dict(data=data, records=records, form=form)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def group():
-
-    """ RESTful CRUD controller """
-
-    prefix = "auth"
-    resourcename = "group"
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    # Model options
-
-    # CRUD Strings
-    ADD_ROLE = T("Add Role")
-    LIST_ROLES = T("List Roles")
-    s3.crud_strings[tablename] = Storage(
-        title_create = ADD_ROLE,
-        title_display = T("Role Details"),
-        title_list = LIST_ROLES,
-        title_update = T("Edit Role"),
-        title_search = T("Search Roles"),
-        subtitle_create = T("Add New Role"),
-        subtitle_list = T("Roles"),
-        label_list_button = LIST_ROLES,
-        label_create_button = ADD_ROLE,
-        msg_record_created = T("Role added"),
-        msg_record_modified = T("Role updated"),
-        msg_record_deleted = T("Role deleted"),
-        msg_list_empty = T("No Roles currently defined"))
-
-    s3xrc.model.configure(table, main="role")
-    return s3_rest_controller(prefix, resourcename)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def membership():
-
-    """ RESTful CRUD controller """
-
-    prefix = "auth"
-    resourcename = "membership"
-    tablename = prefix + "_" + resourcename
-    table = db[tablename]
-
-    # Model options
-    db.auth_membership.group_id.represent = shn_role_represent
-    db.auth_membership.user_id.represent = shn_user_represent
-
-    # CRUD Strings
-    ADD_MEMBERSHIP = T("Add Membership")
-    LIST_MEMBERSHIPS = T("List Memberships")
-    s3.crud_strings[tablename] = Storage(
-        title_create = ADD_MEMBERSHIP,
-        title_display = T("Membership Details"),
-        title_list = LIST_MEMBERSHIPS,
-        title_update = T("Edit Membership"),
-        title_search = T("Search Memberships"),
-        subtitle_create = T("Add New Membership"),
-        subtitle_list = T("Memberships"),
-        label_list_button = LIST_MEMBERSHIPS,
-        label_create_button = ADD_MEMBERSHIP,
-        msg_record_created = T("Membership added"),
-        msg_record_modified = T("Membership updated"),
-        msg_record_deleted = T("Membership deleted"),
-        msg_list_empty = T("No Memberships currently defined"))
-
-    s3xrc.model.configure(table, main="user_id")
-    return s3_rest_controller(prefix, resourcename)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def users():
-    """
-    List/amend which users are in a Group
-
-    @deprecated
-
-    """
-
-    try:
-        group = int(request.args(0))
-    except TypeError, ValueError:
-        session.error = T("Need to specify a role!")
-        redirect(URL(r=request, f="group"))
-
-    table = db.auth_membership
-    query = table.group_id == group
-    title = T("Role") + ": " + db.auth_group[group].role
-    description = db.auth_group[group].description
-    # Start building the Return
-    output = dict(title=title, description=description, group=group)
-
-    if auth.settings.username:
-        username = "username"
-    else:
-        username = "email"
-
-    # Audit
-    crud.settings.create_onaccept = lambda form: s3_audit("create", module, "membership",
-                                                          form=form,
-                                                          representation="html")
-    crud.settings.create_onvalidation = lambda form: group_dupes(form, "users", [group])
-    # Many<>Many selection (Deletable, no Quantity)
-    item_list = []
-    sqlrows = db(query).select()
-    even = True
-    for row in sqlrows:
-        if even:
-            theclass = "even"
-            even = False
-        else:
-            theclass = "odd"
-            even = True
-        id = row.user_id
-        _user = db.auth_user[id]
-        item_first = _user.first_name
-        item_second = _user.last_name
-        item_description = _user[username]
-        id_link = A(id, _href=URL(r=request, f="user", args=[id, "read"]))
-        checkbox = INPUT(_type="checkbox", _value="on", _name=id, _class="remove_item")
-        item_list.append(TR(TD(id_link), TD(item_first), TD(item_second), TD(item_description), TD(checkbox), _class=theclass))
-
-    if auth.settings.username:
-        username_label = T("Username")
-    else:
-        username_label = T("Email")
-    table_header = THEAD(TR(TH("ID"), TH(T("First Name")), TH(T("Last Name")), TH(username_label), TH(T("Remove"))))
-    table_footer = TFOOT(TR(TD(_colspan=4), TD(INPUT(_id="submit_delete_button", _type="submit", _value=T("Remove")))))
-    items = DIV(FORM(
-        TABLE(table_header,
-              TBODY(item_list),
-              table_footer, _id="list", _class="display"), _name="custom", _method="post", _enctype="multipart/form-data", _action=URL(r=request, f="group_remove_users", args=[group])))
-
-    subtitle = T("Users")
-    crud.messages.submit_button = T("Add")
-    crud.messages.record_created = T("Role Updated")
-    form = crud.create(table, next=URL(r=request, args=[group]))
-    addtitle = T("Add New User to Role")
-    output.update(dict(subtitle=subtitle, items=items, addtitle=addtitle, form=form))
-    return output
-
-
-# -----------------------------------------------------------------------------
-def group_dupes(form, page, arg):
-    """
-    Onvalidation check for duplicate user roles
-
-    @deprecated
-
-    """
-
-    user = form.latest["user_id"]
-    group = form.latest["group_id"]
-    query = (form.table.user_id == user) & (form.table.group_id == group)
-    items = db(query).select()
-    if items:
-        session.error = T("User already has this role")
-        redirect(URL(r=request, f=page, args=arg))
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def group_remove_users():
-    """
-        Remove users from a group
-    """
-    if len(request.args) == 0:
-        session.error = T("Need to specify a group!")
-        redirect(URL(r=request, f="group"))
-    group = request.args(0)
-    table = db.auth_membership
-    for var in request.vars:
-        if str(var).isdigit():
-            user = var
-            query = (table.group_id == group) & (table.user_id == user)
-            db(query).delete()
-    # Audit
-    #crud.settings.update_onaccept = lambda form: shn_audit_update(form, "membership", "html")
-    session.flash = T("Users removed")
-    redirect(URL(r=request, f="users", args=[group]))
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def groups():
-    """
-        List/amend which groups a User is in
-    """
-
-    try:
-        user = int(request.args(0))
-    except TypeError, ValueError:
-        session.error = T("Need to specify a user!")
-        redirect(URL(r=request, f="user"))
-
-    table = db.auth_membership
-    query = table.user_id == user
-    title = db.auth_user[user].first_name + " " + db.auth_user[user].last_name
-    description = db.auth_user[user].email
-    # Start building the Return
-    output = dict(title=title, description=description, user=user)
-
-    # Audit
-    crud.settings.create_onaccept = lambda form: s3_audit("create", module, "membership",
-                                                          form=form,
-                                                          representation="html")
-
-
-    crud.settings.create_onvalidation = lambda form: group_dupes(form, "groups", [user])
-    # Many<>Many selection (Deletable, no Quantity)
-    item_list = []
-    sqlrows = db(query).select()
-    even = True
-    for row in sqlrows:
-        if even:
-            theclass = "even"
-            even = False
-        else:
-            theclass = "odd"
-            even = True
-        id = row.group_id
-        _group = db.auth_group[id]
-        item_first = _group.role
-        item_description = _group.description
-        id_link = A(id, _href=URL(r=request, f="group", args=[id, "read"]))
-        checkbox = INPUT(_type="checkbox", _value="on", _name=id, _class="remove_item")
-        item_list.append(TR(TD(id_link), TD(item_first), TD(item_description), TD(checkbox), _class=theclass))
-
-    table_header = THEAD(TR(TH("ID"), TH(T("Role")), TH(T("Description")), TH(T("Remove"))))
-    table_footer = TFOOT(TR(TD(_colspan=3), TD(INPUT(_id="submit_delete_button", _type="submit", _value=T("Remove")))))
-    items = DIV(FORM(TABLE(table_header, TBODY(item_list), table_footer, _id="table-container"), _name="custom", _method="post", _enctype="multipart/form-data", _action=URL(r=request, f="user_remove_groups", args=[user])))
-
-    subtitle = T("Roles")
-    crud.messages.submit_button = T("Add")
-    crud.messages.record_created = T("User Updated")
-    form = crud.create(table, next=URL(r=request, args=[user]))
-    addtitle = T("Add New Role to User")
-    output.update(dict(subtitle=subtitle, items=items, addtitle=addtitle, form=form))
-    return output
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def user_remove_groups():
-    """ Remove groups from a user """
-    if len(request.args) == 0:
-        session.error = T("Need to specify a user!")
-        redirect(URL(r=request, f="user"))
-    user = request.args(0)
-    table = db.auth_membership
-    for var in request.vars:
-        if str(var).isdigit():
-            group = var
-            query = (table.group_id == group) & (table.user_id == user)
-            db(query).delete()
-    # Audit
-    #crud.settings.update_onaccept = lambda form: shn_audit_update(form, "membership", "html")
-    session.flash = T("Groups removed")
-    redirect(URL(r=request, f="groups", args=[user]))
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def import_data():
-    """
-        Import data via POST upload to CRUD controller. Old - being replaced by Sync/Importer.
-    """
-    title = T("Import Data")
-    crud.messages.submit_button = "Upload"
-
-    # Deprecated
-    import_job_form = crud.create(db.admin_import_job)
-    # Tell the CRUD create form to post to a different location
-    import_job_form.custom.begin.text = str(import_job_form.custom.begin).replace(
-            'action=""',
-            'action="%s"' % URL(r=request, f="import_job", args=["create"]))
-
-    return dict(title=title,
-                import_job_form=import_job_form)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def import_csv_data():
-    """
-        Import CSV data via POST upload to Database.
-    """
-    file = request.vars.multifile.file
-    try:
-        # Assumes that it is a concatenation of tables
-        import_csv(file)
-        session.flash = T("Data uploaded")
-    except Exception, e:
-        session.error = T("Unable to parse CSV file!")
-    redirect(URL(r=request, f="import_data"))
-
-
-# -----------------------------------------------------------------------------
[e-mail]_login()
-def export_data():
-    """
-        Export data via CRUD controller. Old - being replaced by Sync.
-    """
-    title = T("Export Data")
-    return dict(title=title)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def export_csv():
-    """
-        Export entire database as CSV. Old - being replaced by Sync.
-    """
-    import StringIO
-    output = StringIO.StringIO()
-
-    db.export_to_csv_file(output)
-
-    output.seek(0)
-    import gluon.contenttype
-    response.headers["Content-Type"] = gluon.contenttype.contenttype(".csv")
-    filename = "%s_database.csv" % (request.env.server_name)
-    response.headers["Content-disposition"] = "attachment; filename=%s" % filename
-    return output.read()
-
-
-# -----------------------------------------------------------------------------
-# Unstructured Data Import
-# Deprecated - being replaced by Importer
-@auth.s3_requires_membership(1)
-def import_job():
-    "RESTful CRUD controller to handle 'jobs' for importing unstructured data."
-    # CRUD Strings
-    module = "admin"
-    resource = "import_job"
-    table = "%s_%s" % (module, resource)
-    # This breaks!
-    jr = s3xrc.request(module, resource, request, session=session)
-    CREATE_NEW_IMPORT_JOB = T("Create New Import Job")
-    LIST_IMPORT_JOBS = ("List Import Jobs")
-    s3.crud_strings[table] = Storage(
-            title_create=CREATE_NEW_IMPORT_JOB,
-            title_display=T("Import Job"),
-            title_list=LIST_IMPORT_JOBS,
-            title_update=T("Update Import Job"),
-            subtitle_create=CREATE_NEW_IMPORT_JOB,
-            subtitle_list=T("Import Jobs"),
-            label_list_button=LIST_IMPORT_JOBS,
-            label_create_button=T("Create Import Job"),
-            msg_record_created=T("Import job created"),
-            msg_list_empty=T("No import jobs")
-    )
-
-    if len(request.args) == 0:
-        return _import_job_list(jr)
-    action = request.args(0)
-    if action == "create":
-        return _import_job_create(jr)
-    if action == "update":
-        return _import_job_update(jr)
-
-
-# -----------------------------------------------------------------------------
-def _import_job_list(jr):
-    return shn_list(jr, listadd=False)
-
-
-# -----------------------------------------------------------------------------
-def _import_job_create(jr):
-    if jr.http != "POST":
-        redirect(jr.there())
-
-    def process_new_file_and_redirect(form):
-        filename = form.vars.source_file_newfilename
-        filepath = os.path.join(request.folder, "uploads", filename)
-        query = (jr.table.id == form.vars.id)
-        column_map = []
-        model_fields = dict(map(
-                lambda x:(x.lower(), x),
-                get_matchable_fields(form.vars.module, form.vars.resource)))
-        try:
-            reader = csv.reader(open(filepath, "r"))
-            for line in reader:
-                for col in line:
-                    field = None
-                    col_match = col.lower()
-                    if col_match in model_fields:
-                        # Explicit name match.
-                        field = model_fields.pop(col_match)
-                    if not field:
-                        # Partial name patch.
-                        for field_name in model_fields:
-                            if col_match in field_name or field_name in col_match:
-                                field = model_fields.pop(field_name)
-                                break
-                    column_map.append((col, field))
-                break
-            pickled_map = pickle.dumps(column_map, pickle.HIGHEST_PROTOCOL)
-            db(query).update(column_map=pickled_map)
-        except:
-            db(query).update(status="failed")
-        redirect(URL(r=request, f="import_job", args=[form.vars.id, "update"]))
-
-    form = crud.create(jr.table, onaccept=process_new_file_and_redirect)
-    response.flash = "Form errors!"
-    redirect(URL(r=request, f="import_data"))
-
-
-# -----------------------------------------------------------------------------
-def _import_job_update(jr):
-    if len(request.args) < 2:
-        redirect(jr.there())
-    id = request.args[1]
-    query = (jr.table.id == id)
-    job = db(query).select()
-    if not job:
-        raise HTTP(404, body=s3xrc.xml.json_message(False, 404, session.error))
-    job = job[0]
-
-    if jr.http == "GET":
-        output = _import_job_update_GET(jr, job)
-    elif jr.http == "POST":
-        output = _import_job_update_POST(jr, job)
-    else:
-        raise HTTP(400, body=INVALIDREQUEST)
-
-    title = "%s - %s" % (T("Input Job"), job.description)
-    output.update(dict(title=title, job=job))
-    response.view = "admin/import_job_update.html"
-    return output
-
-
-# -----------------------------------------------------------------------------
-def _import_job_update_GET(jr, job):
-    table = db.admin_import_line
-    query = (table.import_job == job.id)
-
-    if job.status == "new":
-        try:
-            job.column_map = pickle.loads(job.column_map)
-        except pickle.UnpicklingError:
-            job.column_map = []
-        model_fields = get_matchable_fields(job.module, job.resource)
-        return dict(model_fields=model_fields)
-
-    if job.status == "processing":
-        num_lines = db(query).count()
-        return dict(num_lines=num_lines, update_speed=60)
-
-    if job.status in ["processed", "failed", "imported"]:
-        def _include_field(f):
-            if f in ["import_job"]:
-                return False
-            return table[f].readable
-
-        fields = [table[f] for f in table.fields if _include_field(f)]
-        headers = dict(map(lambda f: (str(f), f.label), fields))
-        items = crud.select(
-                db["admin_import_line"],
-                query=query,
-                fields=fields,
-                headers=headers,
-                truncate=48, _id="list", _class="display")
-        response.extra_styles = ["admin/import_job.css"]
-        return dict(items=items)
-
-    if job.status == "import":
-        query = (table.import_job == job.id) & (table.status == "imported")
-        num_lines = db(query).count()
-        return dict(num_lines=num_lines, update_speed=60)
-
-    return {}
-
-
-# -----------------------------------------------------------------------------
-def _import_job_update_POST(jr, job):
-    if job.status == "new":
-        # Update column map.
-        try:
-            column_map = pickle.loads(job.column_map)
-        except pickle.UnpicklingError:
-            column_map = []
-        for key, value in request.vars.iteritems():
-            if not key.startswith("column_map_"):
-                continue
-            try:
-                idx = int(key.split("_")[-1])
-            except ValueError:
-                continue
-            if value != "None (Ignore)":
-                column_map[idx] = (column_map[idx][0], value)
-            else:
-                column_map[idx] = (column_map[idx][0], None)
-        jr.table[job.id] = dict(
-                column_map=pickle.dumps(column_map, pickle.HIGHEST_PROTOCOL),
-                status="processing")
-        job.status = "processing"
-
-    if job.status == "processed":
-        query = db.admin_import_line.id
-        for var, status in request.vars.iteritems():
-            if not var.startswith("status_"):
-                continue
-            try:
-                import_line_id = int(var.split("_")[-1])
-            except ValueError:
-                continue
-            db(db.admin_import_line.id == import_line_id).update(status=status)
-        jr.table[job.id] = dict(status="import")
-        job.status = "import"
-
-    return _import_job_update_GET(jr, job)
-
-
-# -----------------------------------------------------------------------------
-def get_matchable_fields(module, resource):
-    model_fields = getattr(db, "%s_%s" % (module, resource)).fields
-    for name in ["created_on", "modified_on", "id", "uuid", "deleted"]:
-        model_fields.remove(name)
-    model_fields.insert(0, "None (Ignore)")
-    return model_fields
-
-
-
-# -----------------------------------------------------------------------------
-# Functional Testing
-# Deprecated: Use static/selenium/scripts/regressionTests.py with it's Tk UI
-def handleResults():
-    """
-        Process the POST data returned from Selenium TestRunner.
-        The data is written out to 2 files.  The overall results are written to
-        date-time-browserName-metadata.txt as a list of key: value, one per line.  The
-        suiteTable and testTables are written to date-time-browserName-results.html.
-    """
-
-    if not request.vars.result:
-        # No results
-        return
-
-    # Read in results
-    result = request.vars.result
-    totalTime = request.vars.totalTime
-    numberOfSuccesses = request.vars.numTestPasses
-    numberOfFailures = request.vars.numTestFailures
-    numberOfCommandSuccesses = request.vars.numCommandPasses
-    numberOfCommandFailures = request.vars.numCommandFailures
-    numberOfCommandErrors = request.vars.numCommandErrors
-
-    suiteTable = ""
-    if request.vars.suite:
-        suiteTable = request.vars.suite
-
-    testTables = []
-    testTableNum = 1
-    while request.vars["testTable.%s" % testTableNum]:
-        testTable = request.vars["testTable.%s" % testTableNum]
-        testTables.append(testTable)
-        testTableNum += 1
-        try:
-            request.vars["testTable.%s" % testTableNum]
-            pass
-        except:
-            break
-
-    # Unescape the HTML tables
-    import urllib
-    suiteTable = urllib.unquote(suiteTable)
-    testTables = map(urllib.unquote, testTables)
-
-    # We want to store results separately for each browser
-    browserName = getBrowserName(request.env.http_user_agent)
-    date = str(request.utcnow)[:-16]
-    time = str(request.utcnow)[11:-10]
-    time = time.replace(":", "-")
-
-    # Write out results
-    outputDir = os.path.join(request.folder, "static", "selenium", "results")
-    metadataFile = "%s-%s-%s-metadata.txt" % (date, time, browserName)
-    dataFile = "%s-%s-%s-results.html" % (date, time, browserName)
-
-    #xmlText = '<selenium result="' + result + '" totalTime="' + totalTime + '" successes="' + numberOfCommandSuccesses + '" failures="' + numberOfCommandFailures + '" errors="' + numberOfCommandErrors + '" />'
-    f = open(os.path.join(outputDir, metadataFile), "w")
-    for key in request.vars.keys():
-        if "testTable" in key or key in ["log", "suite"]:
-            pass
-        else:
-            print >> f, "%s: %s" % (key, request.vars[key])
-    f.close()
-
-    f = open(os.path.join(outputDir, dataFile), "w")
-    print >> f, suiteTable
-    for testTable in testTables:
-        print >> f, "<br/><br/>"
-        print >> f, testTable
-    f.close()
-
-    message = DIV(P("Results have been successfully posted to the server here:"),
-        P(A(metadataFile, _href=URL(r=request, c="static", f="selenium", args=["results", metadataFile]))),
-        P(A(dataFile, _href=URL(r=request, c="static", f="selenium", args=["results", dataFile]))))
-
-    response.view = "display.html"
-    title = T("Test Results")
-    return dict(title=title, item=message)
-
-
-# -----------------------------------------------------------------------------
-# Ticket Viewer functions Borrowed from admin application of web2py
-@auth.s3_requires_membership(1)
-def errors():
-    """ Error handler """
-
-    app = request.application
-
-    for item in request.vars:
-        if item[:7] == "delete_":
-            os.unlink(apath("%s/errors/%s" % (app, item[7:]), r=request))
-
-    func = lambda p: os.stat(apath("%s/errors/%s" % (app, p), r=request)).st_mtime
-    tickets = sorted(listdir(apath("%s/errors/" % app, r=request), "^\w.*"),
-                     key=func,
-                     reverse=True)
-
-    return dict(app=app, tickets=tickets)
-
-
-# -----------------------------------------------------------------------------
-def make_link(path):
-    """ Create a link from a path """
-    tryFile = path.replace("\\", "/")
-
-    if os.path.isabs(tryFile) and os.path.isfile(tryFile):
-        (folder, filename) = os.path.split(tryFile)
-        (base, ext) = os.path.splitext(filename)
-        app = request.args[0]
-
-        editable = {"controllers": ".py", "models": ".py", "views": ".html"}
-        for key in editable.keys():
-            check_extension = folder.endswith("%s/%s" % (app, key))
-            if ext.lower() == editable[key] and check_extension:
-                return A('"' + tryFile + '"',
-                         _href=URL(r=request,
-                         f="edit/%s/%s/%s" % (app, key, filename))).xml()
-    return ""
-
-
-# -----------------------------------------------------------------------------
-def make_links(traceback):
-    """ Make links using the given traceback """
-
-    lwords = traceback.split('"')
-
-    # Make the short circuit compatible with <= python2.4
-    result = (len(lwords) != 0) and lwords[0] or ""
-
-    i = 1
-
-    while i < len(lwords):
-        link = make_link(lwords[i])
-
-        if link == "":
-            result += '"' + lwords[i]
-        else:
-            result += link
-
-            if i + 1 < len(lwords):
-                result += lwords[i + 1]
-                i = i + 1
-
-        i = i + 1
-
-    return result
-
-
-# -----------------------------------------------------------------------------
-class TRACEBACK(object):
-    """ Generate the traceback """
-
-    def __init__(self, text):
-        """ TRACEBACK constructor """
-
-        self.s = make_links(CODE(text).xml())
-
-    def xml(self):
-        """ Returns the xml """
-
-        return self.s
-
-
-# -----------------------------------------------------------------------------
-# Ticket viewing
-@auth.s3_requires_membership(1)
-def ticket():
-    """ Ticket handler """
-
-    if len(request.args) != 2:
-        session.flash = T("Invalid ticket")
-        redirect(URL(r=request))
-
-    app = request.args[0]
-    ticket = request.args[1]
-    e = RestrictedError()
-    e.load(request, app, ticket)
-
-    return dict(app=app,
-                ticket=ticket,
-                traceback=TRACEBACK(e.traceback),
-                code=e.code,
-                layer=e.layer)
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def role():
-    """
-    Role Manager
-
-    @author: Dominic König <[e-mail]>
-
-    """
-
-    prefix = "auth"
-    name = "group"
-
-    # ACLs as component of roles
-    s3xrc.model.add_component("s3", "permission",
-        joinby = dict(auth_group="group_id"),
-        multiple=True)
-
-    def prep(r):
-        if r.representation not in ("html",):
-            return False
-
-        handler = s3base.S3RoleManager()
-        modules = deployment_settings.modules
-        handler.controllers = Storage([(m, modules[m]) for m in modules
-                                                       if modules[m].restricted])
-
-        # Configure REST methods
-        resource = r.resource
-        resource.add_method("users", handler)
-        resource.set_handler("read", handler)
-        resource.set_handler("list", handler)
-        resource.set_handler("copy", handler)
-        resource.set_handler("create", handler)
-        resource.set_handler("update", handler)
-        resource.set_handler("delete", handler)
-        return True
-    response.s3.prep = prep
-
-    response.s3.no_sspag = True
-    response.extra_styles = ["S3/role.css"]
-
-    output = s3_rest_controller(prefix, name)
-    return output
-
-
-# -----------------------------------------------------------------------------
-@auth.s3_requires_membership(1)
-def acl():
-    """
-    Preliminary controller for ACLs
-    for testing purposes, not for production use!
-
-    """
-
-    prefix = "s3"
-    name = "permission"
-
-    table = auth.permission.table
-    table.group_id.requires = IS_ONE_OF(db, "auth_group.id", "%(role)s")
-    table.group_id.represent = lambda opt: opt and db.auth_group[opt].role or opt
-
-    table.controller.requires = IS_EMPTY_OR(IS_IN_SET(auth.permission.modules.keys(), zero="ANY"))
-    table.controller.represent = lambda opt: opt and "%s (%s)" % (opt, auth.permission.modules.get(opt, {}).get("name_nice", opt)) or "ANY"
-
-    table.function.represent = lambda val: val and val or T("ANY")
-
-    table.tablename.requires = IS_EMPTY_OR(IS_IN_SET([t._tablename for t in db], zero=T("ANY")))
-    table.tablename.represent = lambda val: val and val or T("ANY")
-
-    table.uacl.label = T("All Resources")
-    table.uacl.widget = S3ACLWidget.widget
-    table.uacl.requires = IS_ACL(auth.permission.PERMISSION_OPTS)
-    table.uacl.represent = lambda val: acl_represent(val, auth.permission.PERMISSION_OPTS)
-
-    table.oacl.label = T("Owned Resources")
-    table.oacl.widget = S3ACLWidget.widget
-    table.oacl.requires = IS_ACL(auth.permission.PERMISSION_OPTS)
-    table.oacl.represent = lambda val: acl_represent(val, auth.permission.PERMISSION_OPTS)
-
-    s3xrc.model.configure(table,
-        create_next = URL(r=request),
-        update_next = URL(r=request))
-
-    output = s3_rest_controller(prefix, name)
-    return output
-
-
-# -----------------------------------------------------------------------------
-def acl_represent(acl, options):
-    """
-    Represent ACLs in tables
-    for testing purposes, not for production use!
-
-    """
-
-    values = []
-
-    for o in options.keys():
-        if o == 0 and acl == 0:
-            values.append("%s" % options[o][0])
-        elif acl and acl & o == o:
-            values.append("%s" % options[o][0])
-        else:
-            values.append("_")
-
-    return " ".join(values)
-
-# -----------------------------------------------------------------------------

=== added file 'controllers/appadmin.py'
--- controllers/appadmin.py	1970-01-01 00:00:00 +0000
+++ controllers/appadmin.py	2011-01-24 22:41:50 +0000
@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+
+"""
+    Application Admin Controllers
+"""
+
+import os
+#import socket
+import datetime
+import copy
+import gluon.contenttype
+import gluon.fileutils
+
+# ## crytical --- make a copy of the environment
+
+global_env = copy.copy(globals())
+global_env['datetime'] = datetime
+
+#
+# Native Web2Py Auth (localhost & site password)
+#
+#http_host = request.env.http_host.split(':')[0]
+#remote_addr = request.env.remote_addr
+#try:
+#    hosts = (http_host, socket.gethostbyname(remote_addr))
+#except:
+#    hosts = (http_host, )
+#if remote_addr not in hosts:
+#    raise HTTP(400)
+#if not gluon.fileutils.check_credentials(request):
+#    redirect('/admin')
+
+#
+# S3 Auth
+#
+if not s3_has_role(1):
+    unauthorised()
+
+module = "admin"
+
+# Options Menu (available in all Functions' Views)
+response.menu_options = admin_menu_options
+
+ignore_rw = True
+response.view = "admin/appadmin.html"
+#response.menu = [[T("design"), False, URL("admin", "default", "design",
+#                 args=[request.application])], [T("db"), False,
+#                 URL(r=request, f="index")], [T("state"), False,
+#                 URL(r=request, f="state")]]
+
+
+# ##########################################################
+# ## auxiliary functions
+# ###########################################################
+
+
+def get_databases(request):
+    dbs = {}
+    for (key, value) in global_env.items():
+        cond = False
+        try:
+            cond = isinstance(value, GQLDB)
+        except:
+            cond = isinstance(value, SQLDB)
+        if cond:
+            dbs[key] = value
+    return dbs
+
+
+databases = get_databases(None)
+
+
+def eval_in_global_env(text):
+    exec ('_ret=%s' % text, {}, global_env)
+    return global_env['_ret']
+
+
+def get_database(request):
+    if request.args and request.args(0) in databases:
+        return eval_in_global_env(request.args(0))
+    else:
+        session.flash = T('invalid request')
+        redirect(URL(r=request, f='index'))
+
+
+def get_table(request):
+    db = get_database(request)
+    if len(request.args) > 1 and request.args[1] in db.tables:
+        return (db, request.args[1])
+    else:
+        session.flash = T('invalid request')
+        redirect(URL(r=request, f='index'))
+
+
+def get_query(request):
+    try:
+        return eval_in_global_env(request.vars.query)
+    except Exception:
+        return None
+
+
+# ##########################################################
+# ## list all databases and tables
+# ###########################################################
+
+
+def index():
+    return dict(databases=databases)
+
+
+# ##########################################################
+# ## insert a new record
+# ###########################################################
+
+
+def insert():
+    (db, table) = get_table(request)
+    form = SQLFORM(db[table], ignore_rw=ignore_rw)
+    if form.accepts(request.vars, session):
+        response.flash = T('new record inserted')
+    return dict(form=form)
+
+
+# ##########################################################
+# ## list all records in table and insert new record
+# ###########################################################
+
+
+def download():
+    import os
+    db = get_database(request)
+    return response.download(request,db)
+
+def csv():
+    import gluon.contenttype
+    response.headers['Content-Type'] = \
+        gluon.contenttype.contenttype('.csv')
+    db = get_database(request)
+    query = get_query(request)
+    if not query:
+        return None
+    response.headers['Content-disposition'] = 'attachment; filename=%s_%s.csv'\
+         % tuple(request.vars.query.split('.')[:2])
+    return str(db(query).select())
+
+
+def import_csv(table, file):
+    table.import_from_csv_file(file)
+
+def select():
+    import re
+    db = get_database(request)
+    dbname = request.args(0)
+    regex = re.compile('(?P<table>\w+)\.(?P<field>\w+)=(?P<value>\d+)')
+    if request.vars.query:
+        match = regex.match(request.vars.query)
+        if match:
+            request.vars.query = '%s.%s.%s==%s' % (request.args(0),
+                    match.group('table'), match.group('field'),
+                    match.group('value'))
+    else:
+        request.vars.query = session.last_query
+    query = get_query(request)
+    if request.vars.start:
+        start = int(request.vars.start)
+    else:
+        start = 0
+    nrows = 0
+    stop = start + 100
+    table = None
+    rows = []
+    orderby = request.vars.orderby
+    if orderby:
+        orderby = dbname + '.' + orderby
+        if orderby == session.last_orderby:
+            if orderby[0] == '~':
+                orderby = orderby[1:]
+            else:
+                orderby = '~' + orderby
+    session.last_orderby = orderby
+    session.last_query = request.vars.query
+    form = FORM(TABLE(TR(T('Query') + ':', '', INPUT(_style='width:400px',
+                _name='query', _value=request.vars.query or '',
+                requires=IS_NOT_EMPTY(error_message=T("Cannot be empty")))), TR(T('Update') + ':',
+                INPUT(_name='update_check', _type='checkbox',
+                value=False), INPUT(_style='width:400px',
+                _name='update_fields', _value=request.vars.update_fields
+                 or '')), TR(T('Delete') + ":", INPUT(_name='delete_check',
+                _class='delete', _type='checkbox', value=False), ''),
+                TR('', '', INPUT(_type='submit', _value='submit'))),
+                _action=URL(r=request,args=request.args))
+    if request.vars.csvfile != None:
+        try:
+            import_csv(db[request.vars.table],
+                       request.vars.csvfile.file)
+            response.flash = T('data uploaded')
+        except:
+            response.flash = T('unable to parse csv file')
+    if form.accepts(request.vars, formname=None):
+        regex = re.compile(request.args(0) + '\.(?P<table>\w+)\.id\>0')
+        match = regex.match(form.vars.query.strip())
+        if match:
+            table = match.group('table')
+        try:
+            nrows = db(query).count()
+            if form.vars.update_check and form.vars.update_fields:
+                db(query).update(**eval_in_global_env('dict(%s)'
+                                  % form.vars.update_fields))
+                response.flash = T('%s rows updated', nrows)
+            elif form.vars.delete_check:
+                db(query).delete()
+                response.flash = T('%s rows deleted', nrows)
+            nrows = db(query).count()
+            if orderby:
+                rows = db(query).select(limitby=(start, stop),
+                        orderby=eval_in_global_env(orderby))
+            else:
+                rows = db(query).select(limitby=(start, stop))
+        except:
+            (rows, nrows) = ([], 0)
+            response.flash = T('Invalid Query')
+    return dict(
+        form=form,
+        table=table,
+        start=start,
+        stop=stop,
+        nrows=nrows,
+        rows=rows,
+        query=request.vars.query
+        )
+
+
+# ##########################################################
+# ## edit delete one record
+# ###########################################################
+
+
+def update():
+    (db, table) = get_table(request)
+    try:
+        id = int(request.args[2])
+        record = db(db[table].id == id).select().first()
+    except:
+        session.flash = T('record does not exist')
+        redirect(URL(r=request, f='select', args=request.args[:1],
+                 vars=dict(query='%s.%s.id>0'
+                  % tuple(request.args[:2]))))
+    form = SQLFORM(db[table], record, deletable=True, delete_label=T('Check to delete'), ignore_rw=ignore_rw,
+                   linkto=URL(r=request, f='select',
+                   args=request.args[:1]), upload=URL(r=request,
+                   f='download', args=request.args[:1]))
+    if form.accepts(request.vars, session):
+        response.flash = T('done!')
+        redirect(URL(r=request, f='select', args=request.args[:1],
+                 vars=dict(query='%s.%s.id>0'
+                  % tuple(request.args[:2]))))
+    return dict(form=form)
+
+
+# ##########################################################
+# ## get global variables
+# ###########################################################
+
+
+def state():
+    return dict()
+
+

=== removed file 'controllers/appadmin.py'
--- controllers/appadmin.py	2011-01-11 21:17:57 +0000
+++ controllers/appadmin.py	1970-01-01 00:00:00 +0000
@@ -1,268 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    Application Admin Controllers
-"""
-
-import os
-#import socket
-import datetime
-import copy
-import gluon.contenttype
-import gluon.fileutils
-
-# ## crytical --- make a copy of the environment
-
-global_env = copy.copy(globals())
-global_env['datetime'] = datetime
-
-#
-# Native Web2Py Auth (localhost & site password)
-#
-#http_host = request.env.http_host.split(':')[0]
-#remote_addr = request.env.remote_addr
-#try:
-#    hosts = (http_host, socket.gethostbyname(remote_addr))
-#except:
-#    hosts = (http_host, )
-#if remote_addr not in hosts:
-#    raise HTTP(400)
-#if not gluon.fileutils.check_credentials(request):
-#    redirect('/admin')
-
-#
-# S3 Auth
-#
-if not s3_has_role(1):
-    unauthorised()
-
-module = "admin"
-
-# Options Menu (available in all Functions' Views)
-response.menu_options = admin_menu_options
-
-ignore_rw = True
-response.view = "admin/appadmin.html"
-#response.menu = [[T("design"), False, URL("admin", "default", "design",
-#                 args=[request.application])], [T("db"), False,
-#                 URL(r=request, f="index")], [T("state"), False,
-#                 URL(r=request, f="state")]]
-
-
-# ##########################################################
-# ## auxiliary functions
-# ###########################################################
-
-
-def get_databases(request):
-    dbs = {}
-    for (key, value) in global_env.items():
-        cond = False
-        try:
-            cond = isinstance(value, GQLDB)
-        except:
-            cond = isinstance(value, SQLDB)
-        if cond:
-            dbs[key] = value
-    return dbs
-
-
-databases = get_databases(None)
-
-
-def eval_in_global_env(text):
-    exec ('_ret=%s' % text, {}, global_env)
-    return global_env['_ret']
-
-
-def get_database(request):
-    if request.args and request.args(0) in databases:
-        return eval_in_global_env(request.args(0))
-    else:
-        session.flash = T('invalid request')
-        redirect(URL(r=request, f='index'))
-
-
-def get_table(request):
-    db = get_database(request)
-    if len(request.args) > 1 and request.args[1] in db.tables:
-        return (db, request.args[1])
-    else:
-        session.flash = T('invalid request')
-        redirect(URL(r=request, f='index'))
-
-
-def get_query(request):
-    try:
-        return eval_in_global_env(request.vars.query)
-    except Exception:
-        return None
-
-
-# ##########################################################
-# ## list all databases and tables
-# ###########################################################
-
-
-def index():
-    return dict(databases=databases)
-
-
-# ##########################################################
-# ## insert a new record
-# ###########################################################
-
-
-def insert():
-    (db, table) = get_table(request)
-    form = SQLFORM(db[table], ignore_rw=ignore_rw)
-    if form.accepts(request.vars, session):
-        response.flash = T('new record inserted')
-    return dict(form=form)
-
-
-# ##########################################################
-# ## list all records in table and insert new record
-# ###########################################################
-
-
-def download():
-    import os
-    db = get_database(request)
-    return response.download(request,db)
-
-def csv():
-    import gluon.contenttype
-    response.headers['Content-Type'] = \
-        gluon.contenttype.contenttype('.csv')
-    db = get_database(request)
-    query = get_query(request)
-    if not query:
-        return None
-    response.headers['Content-disposition'] = 'attachment; filename=%s_%s.csv'\
-         % tuple(request.vars.query.split('.')[:2])
-    return str(db(query).select())
-
-
-def import_csv(table, file):
-    table.import_from_csv_file(file)
-
-def select():
-    import re
-    db = get_database(request)
-    dbname = request.args(0)
-    regex = re.compile('(?P<table>\w+)\.(?P<field>\w+)=(?P<value>\d+)')
-    if request.vars.query:
-        match = regex.match(request.vars.query)
-        if match:
-            request.vars.query = '%s.%s.%s==%s' % (request.args(0),
-                    match.group('table'), match.group('field'),
-                    match.group('value'))
-    else:
-        request.vars.query = session.last_query
-    query = get_query(request)
-    if request.vars.start:
-        start = int(request.vars.start)
-    else:
-        start = 0
-    nrows = 0
-    stop = start + 100
-    table = None
-    rows = []
-    orderby = request.vars.orderby
-    if orderby:
-        orderby = dbname + '.' + orderby
-        if orderby == session.last_orderby:
-            if orderby[0] == '~':
-                orderby = orderby[1:]
-            else:
-                orderby = '~' + orderby
-    session.last_orderby = orderby
-    session.last_query = request.vars.query
-    form = FORM(TABLE(TR(T('Query') + ':', '', INPUT(_style='width:400px',
-                _name='query', _value=request.vars.query or '',
-                requires=IS_NOT_EMPTY(error_message=T("Cannot be empty")))), TR(T('Update') + ':',
-                INPUT(_name='update_check', _type='checkbox',
-                value=False), INPUT(_style='width:400px',
-                _name='update_fields', _value=request.vars.update_fields
-                 or '')), TR(T('Delete') + ":", INPUT(_name='delete_check',
-                _class='delete', _type='checkbox', value=False), ''),
-                TR('', '', INPUT(_type='submit', _value='submit'))),
-                _action=URL(r=request,args=request.args))
-    if request.vars.csvfile != None:
-        try:
-            import_csv(db[request.vars.table],
-                       request.vars.csvfile.file)
-            response.flash = T('data uploaded')
-        except:
-            response.flash = T('unable to parse csv file')
-    if form.accepts(request.vars, formname=None):
-        regex = re.compile(request.args(0) + '\.(?P<table>\w+)\.id\>0')
-        match = regex.match(form.vars.query.strip())
-        if match:
-            table = match.group('table')
-        try:
-            nrows = db(query).count()
-            if form.vars.update_check and form.vars.update_fields:
-                db(query).update(**eval_in_global_env('dict(%s)'
-                                  % form.vars.update_fields))
-                response.flash = T('%s rows updated', nrows)
-            elif form.vars.delete_check:
-                db(query).delete()
-                response.flash = T('%s rows deleted', nrows)
-            nrows = db(query).count()
-            if orderby:
-                rows = db(query).select(limitby=(start, stop),
-                        orderby=eval_in_global_env(orderby))
-            else:
-                rows = db(query).select(limitby=(start, stop))
-        except:
-            (rows, nrows) = ([], 0)
-            response.flash = T('Invalid Query')
-    return dict(
-        form=form,
-        table=table,
-        start=start,
-        stop=stop,
-        nrows=nrows,
-        rows=rows,
-        query=request.vars.query
-        )
-
-
-# ##########################################################
-# ## edit delete one record
-# ###########################################################
-
-
-def update():
-    (db, table) = get_table(request)
-    try:
-        id = int(request.args[2])
-        record = db(db[table].id == id).select().first()
-    except:
-        session.flash = T('record does not exist')
-        redirect(URL(r=request, f='select', args=request.args[:1],
-                 vars=dict(query='%s.%s.id>0'
-                  % tuple(request.args[:2]))))
-    form = SQLFORM(db[table], record, deletable=True, delete_label=T('Check to delete'), ignore_rw=ignore_rw,
-                   linkto=URL(r=request, f='select',
-                   args=request.args[:1]), upload=URL(r=request,
-                   f='download', args=request.args[:1]))
-    if form.accepts(request.vars, session):
-        response.flash = T('done!')
-        redirect(URL(r=request, f='select', args=request.args[:1],
-                 vars=dict(query='%s.%s.id>0'
-                  % tuple(request.args[:2]))))
-    return dict(form=form)
-
-
-# ##########################################################
-# ## get global variables
-# ###########################################################
-
-
-def state():
-    return dict()
-
-

=== added file 'controllers/assess.py'
--- controllers/assess.py	1970-01-01 00:00:00 +0000
+++ controllers/assess.py	2011-01-24 22:41:50 +0000
@@ -0,0 +1,789 @@
+# -*- coding: utf-8 -*-
+
+""" Assessments - Controller
+
+    @author: Fran Boon
+    @author: Dominic König
+    @author: Michael Howden ([e-mail])
+    @date-created: 2010-08-25
+
+"""
+
+prefix = request.controller
+resourcename = request.function
+
+if prefix not in deployment_settings.modules:
+    session.error = T("Module disabled!")
+    redirect(URL(r=request, c="default", f="index"))
+
+# Options Menu (available in all Functions' Views)
+def shn_menu():
+    menu = [
+        [T("Rapid Assessments"), False, aURL(r=request, f="rat"), [
+            [T("List"), False, aURL(r=request, f="rat")],
+            [T("Add"), False, aURL(p="create", r=request, f="rat", args="create")],
+            #[T("Search"), False, URL(r=request, f="rat", args="search")],
+        ]],
+        [T("Impact Assessments"), False, aURL(r=request, f="assess"), [
+            [T("List"), False, aURL(r=request, f="assess")],
+            #[T("Add"), False, aURL(p="create", r=request, f="assess", args="create")],
+            [T("Add"), False, aURL(r=request, f="basic_assess")],
+            [T("Mobile"), False, aURL(r=request, f="mobile_basic_assess")],
+            #[T("Search"), False, aURL(r=request, f="assess", args="search")],
+        ]],
+    ]
+    if s3_has_role(1):
+        menu_editor = [
+            [T("Edit Options"), False, URL(r=request, f="#"), [
+                [T("List / Add Baseline Types"), False, URL(r=request, f="baseline_type")],
+                [T("List / Add Impact Types"), False, URL(r=request, f="impact_type")],
+            ]],
+        ]
+        menu.extend(menu_editor)
+    response.menu_options = menu
+
+shn_menu()
+
+#==============================================================================
+def index():
+
+    """ Module's Home Page """
+
+    module_name = deployment_settings.modules[prefix].name_nice
+    response.title = module_name
+    return dict(module_name=module_name)
+
+
+# -----------------------------------------------------------------------------
+def maps():
+
+    """ Show a Map of all Rapid Assessments """
+
+    reports = db(db.gis_location.id == db.assess_rat.location_id).select()
+    report_popup_url = URL(r=request, f="rat", args="read.popup?rat.location_id=")
+    map = gis.show_map(feature_queries = [{"name":T("Rapid Assessments"), "query":reports, "active":True, "popup_url": report_popup_url}], window=True)
+
+    return dict(map=map)
+
+
+# -----------------------------------------------------------------------------
+def rat():
+
+    """ Rapid Assessments, RESTful controller """
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    # Don't send the locations list to client (pulled by AJAX instead)
+    table.location_id.requires = IS_NULL_OR(IS_ONE_OF_EMPTY(db, "gis_location.id"))
+
+    # Villages only
+    #table.location_id.requires = IS_NULL_OR(IS_ONE_OF(db(db.gis_location.level == "L5"),
+    #                                                  "gis_location.id",
+    #                                                  repr_select, sort=True))
+
+    # Pre-populate staff ID
+    if auth.is_logged_in():
+        staff_id = db((db.pr_person.uuid == session.auth.user.person_uuid) & \
+                      (db.org_staff.person_id == db.pr_person.id)).select(
+                       db.org_staff.id, limitby=(0, 1)).first()
+        if staff_id:
+            table.staff_id.default = staff_id.id
+
+    # Subheadings in forms:
+    s3xrc.model.configure(db.assess_section2,
+        subheadings = {
+            "Population and number of households": "population_total",
+            "Fatalities": "dead_women",
+            "Casualties": "injured_women",
+            "Missing Persons": "missing_women",
+            "General information on demographics": "household_head_elderly",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section3,
+        subheadings = {
+            "Access to Shelter": "houses_total",
+            "Water storage containers in households": "water_containers_available",
+            "Other non-food items": "cooking_equipment_available",
+            "Shelter/NFI Assistance": "nfi_assistance_available",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section4,
+        subheadings = {
+            "Water supply": "water_source_pre_disaster_type",
+            "Water collection": "water_coll_time",
+            "Places for defecation": "defec_place_type",
+            "Environment": "close_industry",
+            "Latrines": "latrines_number",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section5,
+        subheadings = {
+            "Health services status": "health_services_pre_disaster",
+            "Current health problems": "health_problems_adults",
+            "Nutrition problems": "malnutrition_present_pre_disaster",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section6,
+        subheadings = {
+            "Existing food stocks": "food_stocks_main_dishes",
+            "food_sources" : "Food sources",
+            "Food assistance": "food_assistance_available",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section7,
+        subheadings = {
+            "Sources of income / Major expenses": "income_sources_pre_disaster",
+            "business_damaged" : "Access to cash",
+            "Current community priorities": "rank_reconstruction_assistance",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section8,
+        subheadings = {
+            "Access to education services": "schools_total",
+            "Alternative places for studying": "alternative_study_places_available",
+            "School activities": "schools_open_pre_disaster",
+            "School attendance": "children_0612_female",
+            "School assistance": "school_assistance_available",
+            "Comments": "comments"})
+    s3xrc.model.configure(db.assess_section9,
+        subheadings = {
+            "Physical Safety": "vulnerable_groups_safe_env",
+            "Separated children, caregiving arrangements": "children_separated",
+            "Persons in institutions": "children_in_disabled_homes",
+            "Activities of children": "child_activities_u12f_pre_disaster",
+            "Coping Activities": "coping_activities_elderly",
+            "Current general needs": "current_general_needs",
+            "Comments": "comments"})
+
+    # @ToDo  Generalize this and make it available as a function that other
+    # component prep methods can call to set the default for a join field.
+    def prep(r):
+        if r.representation=="html" and r.http=="GET" and r.method=="create":
+            # If this assessment is being created as a component of a shelter,
+            # it will have the shelter id in its vars.
+            shelter_id = r.request.get_vars.get("rat.shelter_id", None)
+            if shelter_id:
+                try:
+                    shelter_id = int(shelter_id)
+                except ValueError:
+                    pass
+                else:
+                    db.assess_rat.shelter_id.default = shelter_id
+            # If this assessment is being created as a component of a document,
+            # it will have the document id in its vars.
+            document_id = r.request.get_vars.get("rat.document_id", None)
+            if document_id:
+                try:
+                    document_id = int(document_id)
+                except ValueError:
+                    pass
+                else:
+                    db.assess_rat.document_id.default = document_id
+        return True
+    response.s3.prep = prep
+
+    # Post-processor
+    def postp(r, output):
+        shn_action_buttons(r, deletable=False)
+        # Redirect to read/edit view rather than list view
+        if r.representation == "html" and r.method == "create":
+            r.next = r.other(method="",
+                             record_id=s3xrc.get_session("assess", "rat"))
+        return output
+    response.s3.postp = postp
+
+    # Over-ride the listadd since we're not a component here
+    s3xrc.model.configure(table, create_next="", listadd=True)
+
+    rheader = lambda r: shn_rat_rheader(r,
+                                        tabs = [(T("Identification"), None),
+                                                (T("Demographic"), "section2"),
+                                                (T("Shelter & Essential NFIs"), "section3"),
+                                                (T("WatSan"), "section4"),
+                                                (T("Health"), "section5"),
+                                                (T("Nutrition"), "section6"),
+                                                (T("Livelihood"), "section7"),
+                                                (T("Education"), "section8"),
+                                                (T("Protection"), "section9") ])
+
+    output = s3_rest_controller(prefix, resourcename, rheader=rheader)
+
+    response.extra_styles = ["S3/rat.css"]
+    return output
+
+
+# -----------------------------------------------------------------------------
+def shn_rat_rheader(r, tabs=[]):
+
+    """ Resource Headers """
+
+    if r.representation == "html":
+        if r.name == "rat":
+            report = r.record
+            if report:
+                rheader_tabs = shn_rheader_tabs(r, tabs, paging=True)
+                location = report.location_id
+                if location:
+                    location = shn_gis_location_represent(location)
+                staff = report.staff_id
+                if staff:
+                    organisation_id = db(db.org_staff.id == staff).select(db.org_staff.organisation_id).first().organisation_id
+                    organisation = shn_organisation_represent(organisation_id)
+                else:
+                    organisation = None
+                staff = report.staff2_id
+                if staff:
+                    organisation_id = db(db.org_staff.id == staff).select(db.org_staff.organisation_id).first().organisation_id
+                    organisation2 = shn_organisation_represent(organisation_id)
+                else:
+                    organisation2 = None
+                if organisation2:
+                    orgs = organisation + ", " + organisation2
+                else:
+                    orgs = organisation
+                doc_name = doc_url = None
+                document = db(db.doc_document.id == report.document_id).select(db.doc_document.name, db.doc_document.file, limitby=(0, 1)).first()
+                if document:
+                    doc_name = document.name
+                    doc_url = URL(r=request, c="default", f="download", args=[document.file])
+                rheader = DIV(TABLE(
+                                TR(
+                                    TH(T("Location") + ": "), location,
+                                    TH(T("Date") + ": "), report.date
+                                  ),
+                                TR(
+                                    TH(T("Organizations") + ": "), orgs,
+                                    TH(T("Document") + ": "), A(doc_name, _href=doc_url)
+                                  )
+                                ),
+                              rheader_tabs)
+
+                return rheader
+    return None
+
+#==============================================================================
+# Flexible Impact Assessments
+#==============================================================================
+def shn_assess_rheader(r, tabs=[]):
+
+    """ Resource Headers for Flexible Impact Assessments """
+
+    if r.representation == "html":
+
+        rheader_tabs = shn_rheader_tabs(r, tabs)
+
+        assess = r.record
+
+        if assess:
+            rheader = DIV(TABLE(TR(
+                                   TH(T("Date & Time") + ": "), assess.datetime,
+                                   TH(T("Location") + ": "), shn_gis_location_represent(assess.location_id),
+                                   TH(T("Assessor") + ": "), shn_pr_person_represent(assess.assessor_person_id),
+                                  ),
+                               ),
+                          rheader_tabs
+                         )
+            return rheader
+
+    return None
+
+
+#==============================================================================
+def assess():
+
+    """ RESTful CRUD controller """
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    # Pre-processor
+    def shn_assess_prep(r):
+        if session.s3.mobile and r.method == "create" and r.representation in shn_interactive_view_formats:
+            # redirect to mobile-specific form:
+            redirect(URL(r=request, f="assess_short_mobile"))
+        return True
+    response.s3.prep = shn_assess_prep
+
+    table.incident_id.comment = DIV(_class="tooltip",
+                                    _title=T("Incident") + "|" + T("Optional link to an Incident which this Assessment was triggered by."))
+
+    tabs = [
+            (T("Edit Details"), None),
+            (T("Baselines"), "baseline"),
+            (T("Impacts"), "impact"),
+            (T("Summary"), "summary"),
+            #(T("Requested"), "ritem"),
+           ]
+
+    rheader = lambda r: shn_assess_rheader(r, tabs)
+
+    return s3_rest_controller(prefix, resourcename, rheader=rheader)
+
+
+#==============================================================================
+def impact_type():
+
+    """ RESTful CRUD controller """
+
+    prefix = "impact"
+    resourcename = "type"
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    return s3_rest_controller(prefix, resourcename)
+
+
+#==============================================================================
+def baseline_type():
+
+    """ RESTful CRUD controller """
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    return s3_rest_controller(prefix, resourcename)
+
+
+#==============================================================================
+def baseline():
+
+    """ RESTful CRUD controller """
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    return s3_rest_controller(prefix, resourcename)
+
+
+#==============================================================================
+def summary():
+
+    """ RESTful CRUD controller """
+
+    tablename = "%s_%s" % (prefix, resourcename)
+    table = db[tablename]
+
+    return s3_rest_controller(prefix, resourcename)
+
+
+#==============================================================================
+def basic_assess():
+    ireport_id = request.vars.get("ireport_id")
+    location = None
+    if incident_id:
+        irs_location_id = shn_get_db_field_value(db = db,
+                                                 table = "irs_ireport",
+                                                 field = "location_id",
+                                                 look_up = ireport_id
+                                                 )
+        location = shn_gis_location_represent(irs_location_id)
+        custom_assess_fields = (
+                           ("impact", 1),
+                           ("impact", 2),
+                           ("impact", 3),
+                           ("impact", 4),
+                           ("impact", 5),
+                           ("impact", 6),
+                           ("impact", 7),
+                           ("assess", "comments"),
+                           )
+        form, form_accepted, assess_id = custom_assess(custom_assess_fields, location_id = irs_location_id)
+    else:
+        custom_assess_fields = (("assess", "location_id", "selector"),
+                           ("impact", 1),
+                           ("impact", 2),
+                           ("impact", 3),
+                           ("impact", 4),
+                           ("impact", 5),
+                           ("impact", 6),
+                           ("impact", 7),
+                           ("assess", "comments"),
+                           )
+        form, form_accepted, assess_id = custom_assess(custom_assess_fields)
+
+
+
+    if form_accepted:
+         response.confirmation = T("Basic Assessment Reported")
+         redirect(URL(r = request, f = "assess", args = [assess_id, "impact"]))
+    return dict(title = T("Basic Assessment"),
+                location = location,
+                form = form)
+
+def mobile_basic_assess():
+    custom_assess_fields = (("assess", "location_id", "auto"),
+                       ("impact", 1),
+                       ("impact", 2),
+                       ("impact", 3),
+                       ("impact", 4),
+                       ("impact", 5),
+                       ("impact", 6),
+                       ("impact", 7),
+                       ("assess", "comments"),
+                       )
+
+    form, form_accepted, assess_id = custom_assess(custom_assess_fields)
+
+    if form_accepted:
+        form = FORM(H1("Sahana Eden"),
+                    H2(T("Short Assessment")),
+                    P(T("Assessment Reported")),
+                    A(T("Report Another Assessment..."),
+                      _href = URL(r=request)
+                      ),
+                    _class = "mobile",
+                    )
+    return dict(form = form)
+
+def color_code_severity_widget(widget, name):
+    for option, color in zip(widget, ["green", "yellow", "orange", "red"]):
+        option[0].__setitem__("_style", "background-color:%s;" % color)
+        option[0][0].__setitem__("_name", name)
+    return widget
+
+def custom_assess(custom_assess_fields, location_id = None):
+    """ Custom page to hide the complexity of the Assessments/Impacts/Summary model for a Mobile device """
+    form_row = []
+    comment = ""
+    for field in custom_assess_fields:
+        name = "custom_%s_%s" % (field[0], field[1])
+        id = name
+        if field[0] == "assess":
+            if field[1] == "comments":
+                label = "%s:" % db.assess_assess[ field[1] ].label
+                #widget = db.assess_assess[ field[1] ].widget
+                widget = TEXTAREA(_name = id,
+                                  _class = "double",
+                                  _type = "text")
+
+            elif field[1] == "location_id":
+                if field[2] == "auto":
+                    #HTML5 Geo-Locate
+                    label = "Location:"
+                    #widget = db.assess_assess[ field[1] ].widget
+                    widget = DIV(INPUT(_name = id,
+                                   _type = "text"),
+                             INPUT(_name = "gis_location_lat",
+                                   _id = "gis_location_lat",
+                                   _type = "text"),
+                             INPUT(_name = "gis_location_lon",
+                                   _id = "gis_location_lon",
+                                   _type = "text"))
+                else:
+                    #Locaton Selector
+                    label = "Location:"
+                    widget = SELECT(_id = id,
+                                    _class = "reference gis_location",
+                                    _name = "location_id")
+                    response.s3.gis.location_id = "custom_assess_location_id"
+        elif field[0] == "baseline":
+            label = shn_get_db_field_value(db = db,
+                                           table = "assess_baseline_type",
+                                           field = "name",
+                                           look_up = field[1]
+                                           )
+            widget = INPUT(_name = id,
+                           _class = "double",
+                           _type = "text")
+
+        elif field[0] == "impact":
+            label = "%s:" % shn_get_db_field_value(db = db,
+                                                   table = "impact_type",
+                                                   field = "name",
+                                                   look_up = field[1]
+                                                   )
+            value_widget = INPUT(_name = id,
+                           _class = "double",
+                           _type = "text")
+            severity_widget = db.assess_summary.value.widget(db.impact_impact.severity,
+                                                       0,
+                                                       _name = name + "_severity"
+                                                       )
+            severity_widget = color_code_severity_widget(severity_widget, name + "_severity")
+
+            widget = DIV(value_widget,
+                         DIV(T("Severity:")),
+                         severity_widget,
+                         XML("&nbsp"))
+
+
+        elif field[0] == "summary":
+            label = "%s:" % shn_org_cluster_subsector_represent( field[1] )
+            widget = db.assess_summary.value.widget(db.assess_summary.value,
+                                                       0,
+                                                       _name = name
+                                                       )
+            widget = color_code_severity_widget(widget)
+
+        #Add the field components to the form_rows
+        if field[0] == "title":
+            form_row.append(TR(H3( field[1] )))
+        else:
+            form_row = form_row + list( s3_formstyle(id + "__row", label, widget, comment) )
+
+    form = FORM(TABLE(*form_row),
+                INPUT(_value = T("Save"),
+                      _type = "submit"
+                      ),
+                )
+    assess_id = None
+    if auth.is_logged_in():
+        form_accepted = form.accepts(request.vars, session)
+        if form_accepted:
+            record_dict = {"organisation_id" : session.s3.organisation_id}
+
+            #Add Assess (must happen first)
+            for field in custom_assess_fields:
+                if field[0] != "assess" or field[1] == "location":
+                    continue
+                name = "custom__assess_%s" % field[1]
+                if name in request.vars:
+                    record_dict[field[1]] = request.vars[name]
+            if "custom_assess_location_id" in request.vars:
+                #Auto
+                if "gis_location_lat" in request.vars:
+                    location_dict = {}
+                    location_dict["lat"] = request.vars["gis_location_lat"]
+                if "gis_location_lon" in request.vars:
+                    location_dict["lon"] = request.vars["gis_location_lon"]
+                location_dict["name"] = request.vars["custom_assess_location_id"]
+                record_dict["location_id"] = db.gis_location.insert(**location_dict)
+            if "location_id" in request.vars:
+                #Location Select
+                record_dict["location_id"] = request.vars["location_id"]
+
+            if location_id:
+                #Location_id was passed to function
+                record_dict["location_id"] =location_id
+
+            assess_id = db.assess_assess.insert(**record_dict)
+
+            fk_dict = dict(baseline = "baseline_type_id",
+                           impact = "impact_type_id",
+                           summary = "cluster_subsector_id"
+                           )
+
+            component_dict = dict(baseline = "assess_baseline",
+                           impact = "impact_impact",
+                           summary = "assess_summary"
+                           )
+
+            # Add Assess Components
+            cluster_summary = {}
+            for field in custom_assess_fields:
+                if field[0] == "assess":
+                    continue
+                record_dict = {}
+                name = "custom_%s_%s" % (field[0], field[1])
+                if name in request.vars:
+                    record_dict["assess_id"] = assess_id
+                    record_dict[fk_dict[ field[0] ] ] = field[1]
+                    record_dict["value"] = request.vars[name]
+                    if field[0] == "impact":
+                        severity = int(request.vars[name + "_severity"])
+                        record_dict["severity"] = severity
+
+                        if not record_dict["value"] and not record_dict["severity"]:
+                            #Do not record impact if there is no data for it.
+                            #Should we still average severity though? Now not doing this
+                            continue
+
+                        #record the Severity per cluster
+                        cluster_id = \
+                            shn_get_db_field_value(db = db,
+                                                   table = "impact_type",
+                                                   field = "cluster_id",
+                                                   look_up = field[1])
+                        if cluster_id in cluster_summary.keys():
+                            cluster_summary[cluster_id].append(severity)
+                        elif cluster_id:
+                            cluster_summary[cluster_id] = [severity]
+
+                    db[component_dict[ field[0] ] ].insert(**record_dict)
+
+            #Add cluster summaries @TODO - make sure that this doesn't happen if there are clusters in the assess
+            for cluster_id in cluster_summary.keys():
+                severity_values = cluster_summary[cluster_id]
+                db.assess_summary.insert(assess_id = assess_id,
+                                         cluster_id = cluster_id,
+                                         #Average severity
+                                         value =sum(severity_values)/len(severity_values)
+                                         )
+
+            # Send Out Notification SMS
+            #message = "Sahana: " + T("New Assessment reported from") + " %s by %s %s" % ( location_dict["name"],
+            #                                                         session.auth.user.first_name,
+            #                                                         session.auth.user.last_name
+            #                                                         )
+            # Hard coded notification message for Demo
+            #msg.send_by_pe_id(    3,
+            #                      subject="",
+            #                      message=message,
+            #                      sender_pe_id = None,
+            #                      pr_message_method = 2,
+            #                      sender="",
+            #                      fromaddress="")
+
+    else:
+         redirect(URL(r=request, c = "default", f = "index"))
+
+    return form, form_accepted, assess_id
+
+#==============================================================================
+def assess_short_mobile():
+
+    """ Custom page to hide the complexity of the Assessments/Impacts/Summary model for a Mobile device """
+
+    assess_short_fields = (("assess", "location"),
+                           ("baseline", 1),
+                           ("baseline", 2),
+                           ("baseline", 4),
+                           ("baseline", 3),
+                           ("impact", 3),
+                           ("impact", 4),
+                           ("title", "Cluster Indicators:"),
+                           ("summary", 4),
+                           ("summary", 3),
+                           ("summary", 10),
+                           ("summary", 11),
+                           ("summary", 9),
+                           ("assess", "comments"),
+                           )
+    form_row = []
+    comment = ""
+    for field in assess_short_fields:
+        name = "assess_short_%s_%s" % (field[0], field[1])
+        id = name
+        if field[0] == "assess":
+            if field[1] == "comments":
+                label = "%s:" % db.assess_assess[ field[1] ].label
+                #widget = db.assess_assess[ field[1] ].widget
+                widget = TEXTAREA(_name = id,
+                                  _class = "double",
+                                  _type = "text")
+
+            elif field[1] == "location":
+                label = "Location:"
+                #widget = db.assess_assess[ field[1] ].widget
+                widget = DIV(INPUT(_name = id,
+                               _type = "text"),
+                         INPUT(_name = "gis_location_lat",
+                               _id = "gis_location_lat",
+                               _type = "text"),
+                         INPUT(_name = "gis_location_lon",
+                               _id = "gis_location_lon",
+                               _type = "text"))
+
+        elif field[0] == "baseline":
+            label = shn_get_db_field_value(db = db,
+                                           table = "assess_baseline_type",
+                                           field = "name",
+                                           look_up = field[1]
+                                           )
+            widget = INPUT(_name = id,
+                           _class = "double",
+                           _type = "text")
+
+        elif field[0] == "impact":
+            label = "%s:" % shn_get_db_field_value(db = db,
+                                                   table = "impact_type",
+                                                   field = "name",
+                                                   look_up = field[1]
+                                                   )
+            widget = INPUT(_name = id,
+                           _class = "double",
+                           _type = "text")
+
+        elif field[0] == "summary":
+            label = "%s:" % shn_org_cluster_subsector_represent( field[1] )
+            widget = db.assess_summary.value.widget(db.assess_summary.value,
+                                                       0,
+                                                       _name = name
+                                                       )
+            for option, color in zip(widget, ["green", "yellow", "orange", "red"]):
+                option[0].__setitem__("_style", "background-color:%s;" % color)
+                option[0][0].__setitem__("_name", name)
+
+        #Add the field components to the form_rows
+        if field[0] == "title":
+            form_row.append(TR(H3( field[1] )))
+        else:
+            form_row = form_row + list( s3_formstyle(id, label, widget, comment) )
+
+    form = FORM(H1("Sahana Eden"),
+                H2(T("Short Assessment")),
+                TABLE(*form_row),
+                INPUT(_value = T("Save"),
+                      _type = "submit"
+                      ),
+                _class = "mobile",
+                )
+
+    if auth.is_logged_in():
+        if form.accepts(request.vars, session):
+            record_dict = {}
+
+            #Add Assess (must happen first)
+            for field in assess_short_fields:
+                if field[0] != "assess" or field[1] == "location":
+                    continue
+                name = "assess_short_assess_%s" % field[1]
+                if name in request.vars:
+                    record_dict[field[1]] = request.vars[name]
+            if "assess_short_assess_location" in request.vars:
+                location_dict = {}
+                location_dict["name"] = request.vars["assess_short_assess_location"]
+                if "gis_location_lat" in request.vars:
+                    location_dict["lat"] = request.vars["gis_location_lat"]
+                if "gis_location_lon" in request.vars:
+                    location_dict["lon"] = request.vars["gis_location_lon"]
+                location_id = db.gis_location.insert(**location_dict)
+                record_dict["location_id"] = location_id
+            assess_id = db.assess_assess.insert(**record_dict)
+
+            fk_dict = dict(baseline = "baseline_type_id",
+                           impact = "impact_type_id",
+                           summary = "cluster_subsector_id"
+                           )
+
+            component_dict = dict(baseline = "assess_baseline",
+                           impact = "impact_impact",
+                           summary = "assess_summary"
+                           )
+
+            # Add Assess Components
+            for field in assess_short_fields:
+                if field[0] == "assess":
+                    continue
+                record_dict = {}
+                name = "assess_short_%s_%s" % (field[0], field[1])
+                if name in request.vars:
+                    record_dict["assess_id"] = assess_id
+                    record_dict[fk_dict[ field[0] ] ] = field[1]
+                    record_dict["value"] = request.vars[name]
+                    db[component_dict[ field[0] ] ].insert(**record_dict)
+
+            # Send Out Notification SMS
+            message = "Sahana: " + T("New Assessment reported from") + " %s by %s %s" % ( location_dict["name"],
+                                                                     session.auth.user.first_name,
+                                                                     session.auth.user.last_name
+                                                                     )
+            # Hard coded notification message for Demo
+            #msg.send_by_pe_id(    3,
+            #                      subject="",
+            #                      message=message,
+            #                      sender_pe_id = None,
+            #                      pr_message_method = 2,
+            #                      sender="",
+            #                      fromaddress="")
+
+            form = FORM(H1("Sahana Eden"),
+                        H2(T("Short Assessment")),
+                        P(T("Assessment Reported")),
+                        A(T("Report Another Assessment..."),
+                          _href = URL(r=request)
+                          ),
+                        _class = "mobile",
+                        )
+    else:
+         redirect(URL(r=request, c = "default", f = "index"))
+
+    return dict(form = form)
+
+#==============================================================================

=== removed file 'controllers/assess.py'
--- controllers/assess.py	2011-01-18 14:42:34 +0000
+++ controllers/assess.py	1970-01-01 00:00:00 +0000
@@ -1,789 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Assessments - Controller
-
-    @author: Fran Boon
-    @author: Dominic König
-    @author: Michael Howden ([e-mail])
-    @date-created: 2010-08-25
-
-"""
-
-prefix = request.controller
-resourcename = request.function
-
-if prefix not in deployment_settings.modules:
-    session.error = T("Module disabled!")
-    redirect(URL(r=request, c="default", f="index"))
-
-# Options Menu (available in all Functions' Views)
-def shn_menu():
-    menu = [
-        [T("Rapid Assessments"), False, aURL(r=request, f="rat"), [
-            [T("List"), False, aURL(r=request, f="rat")],
-            [T("Add"), False, aURL(p="create", r=request, f="rat", args="create")],
-            #[T("Search"), False, URL(r=request, f="rat", args="search")],
-        ]],
-        [T("Impact Assessments"), False, aURL(r=request, f="assess"), [
-            [T("List"), False, aURL(r=request, f="assess")],
-            #[T("Add"), False, aURL(p="create", r=request, f="assess", args="create")],
-            [T("Add"), False, aURL(r=request, f="basic_assess")],
-            [T("Mobile"), False, aURL(r=request, f="mobile_basic_assess")],
-            #[T("Search"), False, aURL(r=request, f="assess", args="search")],
-        ]],
-    ]
-    if s3_has_role(1):
-        menu_editor = [
-            [T("Edit Options"), False, URL(r=request, f="#"), [
-                [T("List / Add Baseline Types"), False, URL(r=request, f="baseline_type")],
-                [T("List / Add Impact Types"), False, URL(r=request, f="impact_type")],
-            ]],
-        ]
-        menu.extend(menu_editor)
-    response.menu_options = menu
-
-shn_menu()
-
-#==============================================================================
-def index():
-
-    """ Module's Home Page """
-
-    module_name = deployment_settings.modules[prefix].name_nice
-    response.title = module_name
-    return dict(module_name=module_name)
-
-
-# -----------------------------------------------------------------------------
-def maps():
-
-    """ Show a Map of all Rapid Assessments """
-
-    reports = db(db.gis_location.id == db.assess_rat.location_id).select()
-    report_popup_url = URL(r=request, f="rat", args="read.popup?rat.location_id=")
-    map = gis.show_map(feature_queries = [{"name":T("Rapid Assessments"), "query":reports, "active":True, "popup_url": report_popup_url}], window=True)
-
-    return dict(map=map)
-
-
-# -----------------------------------------------------------------------------
-def rat():
-
-    """ Rapid Assessments, RESTful controller """
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    # Don't send the locations list to client (pulled by AJAX instead)
-    table.location_id.requires = IS_NULL_OR(IS_ONE_OF_EMPTY(db, "gis_location.id"))
-
-    # Villages only
-    #table.location_id.requires = IS_NULL_OR(IS_ONE_OF(db(db.gis_location.level == "L5"),
-    #                                                  "gis_location.id",
-    #                                                  repr_select, sort=True))
-
-    # Pre-populate staff ID
-    if auth.is_logged_in():
-        staff_id = db((db.pr_person.uuid == session.auth.user.person_uuid) & \
-                      (db.org_staff.person_id == db.pr_person.id)).select(
-                       db.org_staff.id, limitby=(0, 1)).first()
-        if staff_id:
-            table.staff_id.default = staff_id.id
-
-    # Subheadings in forms:
-    s3xrc.model.configure(db.assess_section2,
-        subheadings = {
-            "Population and number of households": "population_total",
-            "Fatalities": "dead_women",
-            "Casualties": "injured_women",
-            "Missing Persons": "missing_women",
-            "General information on demographics": "household_head_elderly",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section3,
-        subheadings = {
-            "Access to Shelter": "houses_total",
-            "Water storage containers in households": "water_containers_available",
-            "Other non-food items": "cooking_equipment_available",
-            "Shelter/NFI Assistance": "nfi_assistance_available",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section4,
-        subheadings = {
-            "Water supply": "water_source_pre_disaster_type",
-            "Water collection": "water_coll_time",
-            "Places for defecation": "defec_place_type",
-            "Environment": "close_industry",
-            "Latrines": "latrines_number",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section5,
-        subheadings = {
-            "Health services status": "health_services_pre_disaster",
-            "Current health problems": "health_problems_adults",
-            "Nutrition problems": "malnutrition_present_pre_disaster",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section6,
-        subheadings = {
-            "Existing food stocks": "food_stocks_main_dishes",
-            "food_sources" : "Food sources",
-            "Food assistance": "food_assistance_available",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section7,
-        subheadings = {
-            "Sources of income / Major expenses": "income_sources_pre_disaster",
-            "business_damaged" : "Access to cash",
-            "Current community priorities": "rank_reconstruction_assistance",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section8,
-        subheadings = {
-            "Access to education services": "schools_total",
-            "Alternative places for studying": "alternative_study_places_available",
-            "School activities": "schools_open_pre_disaster",
-            "School attendance": "children_0612_female",
-            "School assistance": "school_assistance_available",
-            "Comments": "comments"})
-    s3xrc.model.configure(db.assess_section9,
-        subheadings = {
-            "Physical Safety": "vulnerable_groups_safe_env",
-            "Separated children, caregiving arrangements": "children_separated",
-            "Persons in institutions": "children_in_disabled_homes",
-            "Activities of children": "child_activities_u12f_pre_disaster",
-            "Coping Activities": "coping_activities_elderly",
-            "Current general needs": "current_general_needs",
-            "Comments": "comments"})
-
-    # @ToDo  Generalize this and make it available as a function that other
-    # component prep methods can call to set the default for a join field.
-    def prep(r):
-        if r.representation=="html" and r.http=="GET" and r.method=="create":
-            # If this assessment is being created as a component of a shelter,
-            # it will have the shelter id in its vars.
-            shelter_id = r.request.get_vars.get("rat.shelter_id", None)
-            if shelter_id:
-                try:
-                    shelter_id = int(shelter_id)
-                except ValueError:
-                    pass
-                else:
-                    db.assess_rat.shelter_id.default = shelter_id
-            # If this assessment is being created as a component of a document,
-            # it will have the document id in its vars.
-            document_id = r.request.get_vars.get("rat.document_id", None)
-            if document_id:
-                try:
-                    document_id = int(document_id)
-                except ValueError:
-                    pass
-                else:
-                    db.assess_rat.document_id.default = document_id
-        return True
-    response.s3.prep = prep
-
-    # Post-processor
-    def postp(r, output):
-        shn_action_buttons(r, deletable=False)
-        # Redirect to read/edit view rather than list view
-        if r.representation == "html" and r.method == "create":
-            r.next = r.other(method="",
-                             record_id=s3xrc.get_session("assess", "rat"))
-        return output
-    response.s3.postp = postp
-
-    # Over-ride the listadd since we're not a component here
-    s3xrc.model.configure(table, create_next="", listadd=True)
-
-    rheader = lambda r: shn_rat_rheader(r,
-                                        tabs = [(T("Identification"), None),
-                                                (T("Demographic"), "section2"),
-                                                (T("Shelter & Essential NFIs"), "section3"),
-                                                (T("WatSan"), "section4"),
-                                                (T("Health"), "section5"),
-                                                (T("Nutrition"), "section6"),
-                                                (T("Livelihood"), "section7"),
-                                                (T("Education"), "section8"),
-                                                (T("Protection"), "section9") ])
-
-    output = s3_rest_controller(prefix, resourcename, rheader=rheader)
-
-    response.extra_styles = ["S3/rat.css"]
-    return output
-
-
-# -----------------------------------------------------------------------------
-def shn_rat_rheader(r, tabs=[]):
-
-    """ Resource Headers """
-
-    if r.representation == "html":
-        if r.name == "rat":
-            report = r.record
-            if report:
-                rheader_tabs = shn_rheader_tabs(r, tabs, paging=True)
-                location = report.location_id
-                if location:
-                    location = shn_gis_location_represent(location)
-                staff = report.staff_id
-                if staff:
-                    organisation_id = db(db.org_staff.id == staff).select(db.org_staff.organisation_id).first().organisation_id
-                    organisation = shn_organisation_represent(organisation_id)
-                else:
-                    organisation = None
-                staff = report.staff2_id
-                if staff:
-                    organisation_id = db(db.org_staff.id == staff).select(db.org_staff.organisation_id).first().organisation_id
-                    organisation2 = shn_organisation_represent(organisation_id)
-                else:
-                    organisation2 = None
-                if organisation2:
-                    orgs = organisation + ", " + organisation2
-                else:
-                    orgs = organisation
-                doc_name = doc_url = None
-                document = db(db.doc_document.id == report.document_id).select(db.doc_document.name, db.doc_document.file, limitby=(0, 1)).first()
-                if document:
-                    doc_name = document.name
-                    doc_url = URL(r=request, c="default", f="download", args=[document.file])
-                rheader = DIV(TABLE(
-                                TR(
-                                    TH(T("Location") + ": "), location,
-                                    TH(T("Date") + ": "), report.date
-                                  ),
-                                TR(
-                                    TH(T("Organizations") + ": "), orgs,
-                                    TH(T("Document") + ": "), A(doc_name, _href=doc_url)
-                                  )
-                                ),
-                              rheader_tabs)
-
-                return rheader
-    return None
-
-#==============================================================================
-# Flexible Impact Assessments
-#==============================================================================
-def shn_assess_rheader(r, tabs=[]):
-
-    """ Resource Headers for Flexible Impact Assessments """
-
-    if r.representation == "html":
-
-        rheader_tabs = shn_rheader_tabs(r, tabs)
-
-        assess = r.record
-
-        if assess:
-            rheader = DIV(TABLE(TR(
-                                   TH(T("Date & Time") + ": "), assess.datetime,
-                                   TH(T("Location") + ": "), shn_gis_location_represent(assess.location_id),
-                                   TH(T("Assessor") + ": "), shn_pr_person_represent(assess.assessor_person_id),
-                                  ),
-                               ),
-                          rheader_tabs
-                         )
-            return rheader
-
-    return None
-
-
-#==============================================================================
-def assess():
-
-    """ RESTful CRUD controller """
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    # Pre-processor
-    def shn_assess_prep(r):
-        if session.s3.mobile and r.method == "create" and r.representation in shn_interactive_view_formats:
-            # redirect to mobile-specific form:
-            redirect(URL(r=request, f="assess_short_mobile"))
-        return True
-    response.s3.prep = shn_assess_prep
-
-    table.incident_id.comment = DIV(_class="tooltip",
-                                    _title=T("Incident") + "|" + T("Optional link to an Incident which this Assessment was triggered by."))
-
-    tabs = [
-            (T("Edit Details"), None),
-            (T("Baselines"), "baseline"),
-            (T("Impacts"), "impact"),
-            (T("Summary"), "summary"),
-            #(T("Requested"), "ritem"),
-           ]
-
-    rheader = lambda r: shn_assess_rheader(r, tabs)
-
-    return s3_rest_controller(prefix, resourcename, rheader=rheader)
-
-
-#==============================================================================
-def impact_type():
-
-    """ RESTful CRUD controller """
-
-    prefix = "impact"
-    resourcename = "type"
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    return s3_rest_controller(prefix, resourcename)
-
-
-#==============================================================================
-def baseline_type():
-
-    """ RESTful CRUD controller """
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    return s3_rest_controller(prefix, resourcename)
-
-
-#==============================================================================
-def baseline():
-
-    """ RESTful CRUD controller """
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    return s3_rest_controller(prefix, resourcename)
-
-
-#==============================================================================
-def summary():
-
-    """ RESTful CRUD controller """
-
-    tablename = "%s_%s" % (prefix, resourcename)
-    table = db[tablename]
-
-    return s3_rest_controller(prefix, resourcename)
-
-
-#==============================================================================
-def basic_assess():
-    ireport_id = request.vars.get("ireport_id")
-    location = None
-    if incident_id:
-        irs_location_id = shn_get_db_field_value(db = db,
-                                                 table = "irs_ireport",
-                                                 field = "location_id",
-                                                 look_up = ireport_id
-                                                 )
-        location = shn_gis_location_represent(irs_location_id)
-        custom_assess_fields = (
-                           ("impact", 1),
-                           ("impact", 2),
-                           ("impact", 3),
-                           ("impact", 4),
-                           ("impact", 5),
-                           ("impact", 6),
-                           ("impact", 7),
-                           ("assess", "comments"),
-                           )
-        form, form_accepted, assess_id = custom_assess(custom_assess_fields, location_id = irs_location_id)
-    else:
-        custom_assess_fields = (("assess", "location_id", "selector"),
-                           ("impact", 1),
-                           ("impact", 2),
-                           ("impact", 3),
-                           ("impact", 4),
-                           ("impact", 5),
-                           ("impact", 6),
-                           ("impact", 7),
-                           ("assess", "comments"),
-                           )
-        form, form_accepted, assess_id = custom_assess(custom_assess_fields)
-
-
-
-    if form_accepted:
-         response.confirmation = T("Basic Assessment Reported")
-         redirect(URL(r = request, f = "assess", args = [assess_id, "impact"]))
-    return dict(title = T("Basic Assessment"),
-                location = location,
-                form = form)
-
-def mobile_basic_assess():
-    custom_assess_fields = (("assess", "location_id", "auto"),
-                       ("impact", 1),
-                       ("impact", 2),
-                       ("impact", 3),
-                       ("impact", 4),
-                       ("impact", 5),
-                       ("impact", 6),
-                       ("impact", 7),
-                       ("assess", "comments"),
-                       )
-
-    form, form_accepted, assess_id = custom_assess(custom_assess_fields)
-
-    if form_accepted:
-        form = FORM(H1("Sahana Eden"),
-                    H2(T("Short Assessment")),
-                    P(T("Assessment Reported")),
-                    A(T("Report Another Assessment..."),
-                      _href = URL(r=request)
-                      ),
-                    _class = "mobile",
-                    )
-    return dict(form = form)
-
-def color_code_severity_widget(widget, name):
-    for option, color in zip(widget, ["green", "yellow", "orange", "red"]):
-        option[0].__setitem__("_style", "background-color:%s;" % color)
-        option[0][0].__setitem__("_name", name)
-    return widget
-
-def custom_assess(custom_assess_fields, location_id = None):
-    """ Custom page to hide the complexity of the Assessments/Impacts/Summary model for a Mobile device """
-    form_row = []
-    comment = ""
-    for field in custom_assess_fields:
-        name = "custom_%s_%s" % (field[0], field[1])
-        id = name
-        if field[0] == "assess":
-            if field[1] == "comments":
-                label = "%s:" % db.assess_assess[ field[1] ].label
-                #widget = db.assess_assess[ field[1] ].widget
-                widget = TEXTAREA(_name = id,
-                                  _class = "double",
-                                  _type = "text")
-
-            elif field[1] == "location_id":
-                if field[2] == "auto":
-                    #HTML5 Geo-Locate
-                    label = "Location:"
-                    #widget = db.assess_assess[ field[1] ].widget
-                    widget = DIV(INPUT(_name = id,
-                                   _type = "text"),
-                             INPUT(_name = "gis_location_lat",
-                                   _id = "gis_location_lat",
-                                   _type = "text"),
-                             INPUT(_name = "gis_location_lon",
-                                   _id = "gis_location_lon",
-                                   _type = "text"))
-                else:
-                    #Locaton Selector
-                    label = "Location:"
-                    widget = SELECT(_id = id,
-                                    _class = "reference gis_location",
-                                    _name = "location_id")
-                    response.s3.gis.location_id = "custom_assess_location_id"
-        elif field[0] == "baseline":
-            label = shn_get_db_field_value(db = db,
-                                           table = "assess_baseline_type",
-                                           field = "name",
-                                           look_up = field[1]
-                                           )
-            widget = INPUT(_name = id,
-                           _class = "double",
-                           _type = "text")
-
-        elif field[0] == "impact":
-            label = "%s:" % shn_get_db_field_value(db = db,
-                                                   table = "impact_type",
-                                                   field = "name",
-                                                   look_up = field[1]
-                                                   )
-            value_widget = INPUT(_name = id,
-                           _class = "double",
-                           _type = "text")
-            severity_widget = db.assess_summary.value.widget(db.impact_impact.severity,
-                                                       0,
-                                                       _name = name + "_severity"
-                                                       )
-            severity_widget = color_code_severity_widget(severity_widget, name + "_severity")
-
-            widget = DIV(value_widget,
-                         DIV(T("Severity:")),
-                         severity_widget,
-                         XML("&nbsp"))
-
-
-        elif field[0] == "summary":
-            label = "%s:" % shn_org_cluster_subsector_represent( field[1] )
-            widget = db.assess_summary.value.widget(db.assess_summary.value,
-                                                       0,
-                                                       _name = name
-                                                       )
-            widget = color_code_severity_widget(widget)
-
-        #Add the field components to the form_rows
-        if field[0] == "title":
-            form_row.append(TR(H3( field[1] )))
-        else:
-            form_row = form_row + list( s3_formstyle(id + "__row", label, widget, comment) )
-
-    form = FORM(TABLE(*form_row),
-                INPUT(_value = T("Save"),
-                      _type = "submit"
-                      ),
-                )
-    assess_id = None
-    if auth.is_logged_in():
-        form_accepted = form.accepts(request.vars, session)
-        if form_accepted:
-            record_dict = {"organisation_id" : session.s3.organisation_id}
-
-            #Add Assess (must happen first)
-            for field in custom_assess_fields:
-                if field[0] != "assess" or field[1] == "location":
-                    continue
-                name = "custom__assess_%s" % field[1]
-                if name in request.vars:
-                    record_dict[field[1]] = request.vars[name]
-            if "custom_assess_location_id" in request.vars:
-                #Auto
-                if "gis_location_lat" in request.vars:
-                    location_dict = {}
-                    location_dict["lat"] = request.vars["gis_location_lat"]
-                if "gis_location_lon" in request.vars:
-                    location_dict["lon"] = request.vars["gis_location_lon"]
-                location_dict["name"] = request.vars["custom_assess_location_id"]
-                record_dict["location_id"] = db.gis_location.insert(**location_dict)
-            if "location_id" in request.vars:
-                #Location Select
-                record_dict["location_id"] = request.vars["location_id"]
-
-            if location_id:
-                #Location_id was passed to function
-                record_dict["location_id"] =location_id
-
-            assess_id = db.assess_assess.insert(**record_dict)
-
-            fk_dict = dict(baseline = "baseline_type_id",
-                           impact = "impact_type_id",
-                           summary = "cluster_subsector_id"
-                           )
-
-            component_dict = dict(baseline = "assess_baseline",
-                           impact = "impact_impact",
-                           summary = "assess_summary"
-                           )
-
-            # Add Assess Components
-            cluster_summary = {}
-            for field in custom_assess_fields:
-                if field[0] == "assess":
-                    continue
-                record_dict = {}
-                name = "custom_%s_%s" % (field[0], field[1])
-                if name in request.vars:
-                    record_dict["assess_id"] = assess_id
-                    record_dict[fk_dict[ field[0] ] ] = field[1]
-                    record_dict["value"] = request.vars[name]
-                    if field[0] == "impact":
-                        severity = int(request.vars[name + "_severity"])
-                        record_dict["severity"] = severity
-
-                        if not record_dict["value"] and not record_dict["severity"]:
-                            #Do not record impact if there is no data for it.
-                            #Should we still average severity though? Now not doing this
-                            continue
-
-                        #record the Severity per cluster
-                        cluster_id = \
-                            shn_get_db_field_value(db = db,
-                                                   table = "impact_type",
-                                                   field = "cluster_id",
-                                                   look_up = field[1])
-                        if cluster_id in cluster_summary.keys():
-                            cluster_summary[cluster_id].append(severity)
-                        elif cluster_id:
-                            cluster_summary[cluster_id] = [severity]
-
-                    db[component_dict[ field[0] ] ].insert(**record_dict)
-
-            #Add cluster summaries @TODO - make sure that this doesn't happen if there are clusters in the assess
-            for cluster_id in cluster_summary.keys():
-                severity_values = cluster_summary[cluster_id]
-                db.assess_summary.insert(assess_id = assess_id,
-                                         cluster_id = cluster_id,
-                                         #Average severity
-                                         value =sum(severity_values)/len(severity_values)
-                                         )
-
-            # Send Out Notification SMS
-            #message = "Sahana: " + T("New Assessment reported from") + " %s by %s %s" % ( location_dict["name"],
-            #                                                         session.auth.user.first_name,
-            #                                                         session.auth.user.last_name
-            #                                                         )
-            # Hard coded notification message for Demo
-            #msg.send_by_pe_id(    3,
-            #                      subject="",
-            #                      message=message,
-            #                      sender_pe_id = None,
-            #                      pr_message_method = 2,
-            #                      sender="",
-            #                      fromaddress="")
-
-    else:
-         redirect(URL(r=request, c = "default", f = "index"))
-
-    return form, form_accepted, assess_id
-
-#==============================================================================
-def assess_short_mobile():
-
-    """ Custom page to hide the complexity of the Assessments/Impacts/Summary model for a Mobile device """
-
-    assess_short_fields = (("assess", "location"),
-                           ("baseline", 1),
-                           ("baseline", 2),
-                           ("baseline", 4),
-                           ("baseline", 3),
-                           ("impact", 3),
-                           ("impact", 4),
-                           ("title", "Cluster Indicators:"),
-                           ("summary", 4),
-                           ("summary", 3),
-                           ("summary", 10),
-                           ("summary", 11),
-                           ("summary", 9),
-                           ("assess", "comments"),
-                           )
-    form_row = []
-    comment = ""
-    for field in assess_short_fields:
-        name = "assess_short_%s_%s" % (field[0], field[1])
-        id = name
-        if field[0] == "assess":
-            if field[1] == "comments":
-                label = "%s:" % db.assess_assess[ field[1] ].label
-                #widget = db.assess_assess[ field[1] ].widget
-                widget = TEXTAREA(_name = id,
-                                  _class = "double",
-                                  _type = "text")
-
-            elif field[1] == "location":
-                label = "Location:"
-                #widget = db.assess_assess[ field[1] ].widget
-                widget = DIV(INPUT(_name = id,
-                               _type = "text"),
-                         INPUT(_name = "gis_location_lat",
-                               _id = "gis_location_lat",
-                               _type = "text"),
-                         INPUT(_name = "gis_location_lon",
-                               _id = "gis_location_lon",
-                               _type = "text"))
-
-        elif field[0] == "baseline":
-            label = shn_get_db_field_value(db = db,
-                                           table = "assess_baseline_type",
-                                           field = "name",
-                                           look_up = field[1]
-                                           )
-            widget = INPUT(_name = id,
-                           _class = "double",
-                           _type = "text")
-
-        elif field[0] == "impact":
-            label = "%s:" % shn_get_db_field_value(db = db,
-                                                   table = "impact_type",
-                                                   field = "name",
-                                                   look_up = field[1]
-                                                   )
-            widget = INPUT(_name = id,
-                           _class = "double",
-                           _type = "text")
-
-        elif field[0] == "summary":
-            label = "%s:" % shn_org_cluster_subsector_represent( field[1] )
-            widget = db.assess_summary.value.widget(db.assess_summary.value,
-                                                       0,
-                                                       _name = name
-                                                       )
-            for option, color in zip(widget, ["green", "yellow", "orange", "red"]):
-                option[0].__setitem__("_style", "background-color:%s;" % color)
-                option[0][0].__setitem__("_name", name)
-
-        #Add the field components to the form_rows
-        if field[0] == "title":
-            form_row.append(TR(H3( field[1] )))
-        else:
-            form_row = form_row + list( s3_formstyle(id, label, widget, comment) )
-
-    form = FORM(H1("Sahana Eden"),
-                H2(T("Short Assessment")),
-                TABLE(*form_row),
-                INPUT(_value = T("Save"),
-                      _type = "submit"
-                      ),
-                _class = "mobile",
-                )
-
-    if auth.is_logged_in():
-        if form.accepts(request.vars, session):
-            record_dict = {}
-
-            #Add Assess (must happen first)
-            for field in assess_short_fields:
-                if field[0] != "assess" or field[1] == "location":
-                    continue
-                name = "assess_short_assess_%s" % field[1]
-                if name in request.vars:
-                    record_dict[field[1]] = request.vars[name]
-            if "assess_short_assess_location" in request.vars:
-                location_dict = {}
-                location_dict["name"] = request.vars["assess_short_assess_location"]
-                if "gis_location_lat" in request.vars:
-                    location_dict["lat"] = request.vars["gis_location_lat"]
-                if "gis_location_lon" in request.vars:
-                    location_dict["lon"] = request.vars["gis_location_lon"]
-                location_id = db.gis_location.insert(**location_dict)
-                record_dict["location_id"] = location_id
-            assess_id = db.assess_assess.insert(**record_dict)
-
-            fk_dict = dict(baseline = "baseline_type_id",
-                           impact = "impact_type_id",
-                           summary = "cluster_subsector_id"
-                           )
-
-            component_dict = dict(baseline = "assess_baseline",
-                           impact = "impact_impact",
-                           summary = "assess_summary"
-                           )
-
-            # Add Assess Components
-            for field in assess_short_fields:
-                if field[0] == "assess":
-                    continue
-                record_dict = {}
-                name = "assess_short_%s_%s" % (field[0], field[1])
-                if name in request.vars:
-                    record_dict["assess_id"] = assess_id
-                    record_dict[fk_dict[ field[0] ] ] = field[1]
-                    record_dict["value"] = request.vars[name]
-                    db[component_dict[ field[0] ] ].insert(**record_dict)
-
-            # Send Out Notification SMS
-            message = "Sahana: " + T("New Assessment reported from") + " %s by %s %s" % ( location_dict["name"],
-                                                                     session.auth.user.first_name,
-                                                                     session.auth.user.last_name
-                                                                     )
-            # Hard coded notification message for Demo
-            #msg.send_by_pe_id(    3,
-            #                      subject="",
-            #                      message=message,
-            #                      sender_pe_id = None,
-            #                      pr_message_method = 2,
-            #                      sender="",
-            #                      fromaddress="")
-
-            form = FORM(H1("Sahana Eden"),
-                        H2(T("Short Assessment")),
-                        P(T("Assessment Reported")),
-                        A(T("Report Another Assessment..."),
-                          _href = URL(r=request)
-                          ),
-                        _class = "mobile",
-                        )
-    else:
-         redirect(URL(r=request, c = "default", f = "index"))
-
-    return dict(form = form)
-
-#==============================================================================

=== added file 'controllers/auth.py'
--- controllers/auth.py	1970-01-01 00:00:00 +0000
+++ controllers/auth.py	2011-01-24 22:41:50 +0000
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+"""
+    Auth Controllers
+"""
+
+def user():
+    "Defined in admin module, so redirect there"
+    
+    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))
+
+def group():
+    "Defined in admin module, so redirect there"
+    
+    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))
+
+def membership():
+    "Defined in admin module, so redirect there"
+    
+    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))

=== removed file 'controllers/auth.py'
--- controllers/auth.py	2010-06-24 22:07:18 +0000
+++ controllers/auth.py	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    Auth Controllers
-"""
-
-def user():
-    "Defined in admin module, so redirect there"
-    
-    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))
-
-def group():
-    "Defined in admin module, so redirect there"
-    
-    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))
-
-def membership():
-    "Defined in admin module, so redirect there"
-    
-    redirect(URL(r=request, c="admin", args=request.args, vars=request.vars))

=== added file 'controllers/budget.py'
--- controllers/budget.py	1970-01-01 00:00:00 +0000
+++ controllers/budget.py	2011-01-24 22:41:50 +0000
@@ -0,0 +1,1468 @@
+# -*- coding: utf-8 -*-
+
+"""
+    Budgetting Module - Controllers
+"""
+
+module = request.controller
+resourcename = request.function
+
+# Requires 'project' module too
+if module not in deployment_settings.modules or not deployment_settings.has_module("project"):
+    session.error = T("Module disabled!")
+    redirect(URL(r=request, c="default", f="index"))
+
+# Options Menu (available in all Functions' Views)
+response.menu_options = [
+    [T("Parameters"), False, URL(r=request, f="parameters")],
+    [T("Items"), False, URL(r=request, f="item"), [
+        [T("List"), False, URL(r=request, f="item")],
+        [T("Add"), False, URL(r=request, f="item", args="create")],
+    ]],
+    [T("Kits"), False, URL(r=request, f="kit"), [
+        [T("List"), False, URL(r=request, f="kit")],
+        [T("Add"), False, URL(r=request, f="kit", args="create")],
+    ]],
+    [T("Bundles"), False, URL(r=request, f="bundle"), [
+        [T("List"), False, URL(r=request, f="bundle")],
+        [T("Add"), False, URL(r=request, f="bundle", args="create")],
+    ]],
+    [T("Staff"), False, URL(r=request, f="staff"), [
+        [T("List"), False, URL(r=request, f="staff")],
+        [T("Add"), False, URL(r=request, f="staff", args="create")],
+    ]],
+    [T("Locations"), False, URL(r=request, f="location"), [
+        [T("List"), False, URL(r=request, f="location")],
+        [T("Add"), False, URL(r=request, f="location", args="create")],
+    ]],
+    [T("Projects"), False, URL(r=request, f="project"), [
+        [T("List"), False, URL(r=request, f="project")],
+        [T("Add"), False, URL(r=request, f="project", args="create")],
+    ]],
+    [T("Budgets"), False, URL(r=request, f="budget"), [
+        [T("List"), False, URL(r=request, f="budget")],
+        [T("Add"), False, URL(r=request, f="budget", args="create")],
+    ]]
+]
+
+# Options used in multiple functions
+table = db.budget_item
+table.code.label = T("Code")
+table.description.label = T("Description")
+table.unit_cost.label = T("Unit Cost")
+table.monthly_cost.label = T("Monthly Cost")
+table.minute_cost.label = T("Cost per Minute")
+table.megabyte_cost.label = T("Cost per Megabyte")
+table.comments.label = T("Comments")
+
+table = db.budget_kit
+table.code.label = T("Code")
+table.description.label = T("Description")
+table.total_unit_cost.label = T("Total Unit Cost")
+table.total_monthly_cost.label = T("Total Monthly Cost")
+table.total_minute_cost.label = T("Total Cost per Minute")
+table.total_megabyte_cost.label = T("Total Cost per Megabyte")
+table.comments.label = T("Comments")
+
+table = db.budget_kit_item
+table.kit_id.label = T("Kit")
+table.kit_id.represent = lambda kit_id: db(db.budget_kit.id == kit_id).select(db.budget_kit.code, limitby=(0, 1)).first().code
+table.item_id.label = T("Item")
+table.item_id.represent = lambda item_id: db(db.budget_item.id == item_id).select(db.budget_item.description, limitby=(0, 1)).first().description
+table.quantity.label = T("Quantity")
+
+table = db.budget_bundle
+table.name.label = T("Name")
+table.description.label = T("Description")
+table.total_unit_cost.label = T("One time cost")
+table.total_monthly_cost.label = T("Recurring cost")
+table.comments.label = T("Comments")
+
+table = db.budget_bundle_kit
+table.bundle_id.label = T("Bundle")
+table.bundle_id.represent = lambda bundle_id: db(db.budget_bundle.id == bundle_id).select(db.budget_bundle.description, limitby=(0, 1)).first().description
+table.kit_id.label = T("Kit")
+table.kit_id.represent = lambda kit_id: db(db.budget_kit.id == kit_id).select(db.budget_kit.code, limitby=(0, 1)).first().code
+table.quantity.label = T("Quantity")
+table.minutes.label = T("Minutes per Month")
+table.megabytes.label = T("Megabytes per Month")
+
+table = db.budget_bundle_item
+table.bundle_id.label = T("Bundle")
+table.bundle_id.represent = lambda bundle_id: db(db.budget_bundle.id == bundle_id).select(db.budget_bundle.description, limitby=(0, 1)).first().description
+table.item_id.label = T("Item")
+table.item_id.represent = lambda item_id: db(db.budget_item.id == item_id).select(db.budget_item.description, limitby=(0, 1)).first().description
+table.quantity.label = T("Quantity")
+table.minutes.label = T("Minutes per Month")
+table.megabytes.label = T("Megabytes per Month")
+
+table = db.budget_staff
+table.name.label = T("Name")
+table.grade.label = T("Grade")
+table.salary.label = T("Monthly Salary")
+table.travel.label = T("Travel Cost")
+table.comments.label = T("Comments")
+
+table = db.budget_location
+table.code.label = T("Code")
+table.description.label = T("Description")
+table.subsistence.label = T("Subsistence Cost")
+# UN terminology
+#table.subsistence.label = "DSA"
+table.hazard_pay.label = T("Hazard Pay")
+table.comments.label = T("Comments")
+
+#table = db.budget_project
+#table.code.label = T("Code")
+#table.title.label = T("Title")
+#table.comments.label = T("Comments")
+
+table = db.budget_budget
+table.name.label = T("Name")
+table.description.label = T("Description")
+table.total_onetime_costs.label = T("Total One-time Costs")
+table.total_recurring_costs.label = T("Total Recurring Costs")
+table.comments.label = T("Comments")
+
+table = db.budget_budget_bundle
+table.budget_id.label = T("Budget")
+table.budget_id.represent = lambda budget_id: db(db.budget_budget.id == budget_id).select(db.budget_budget.name, limitby=(0, 1)).first().name
+#table.project_id.label = T("Project")
+#table.project_id.represent = lambda project_id: db(db.budget_project.id == project_id).select(db.budget_project.code, limitby=(0, 1)).first().code
+table.location_id.label = T("Location")
+table.location_id.represent = lambda location_id: db(db.budget_location.id == location_id).select(db.budget_location.code, limitby=(0, 1)).first().code
+table.bundle_id.label = T("Bundle")
+table.bundle_id.represent = lambda bundle_id: db(db.budget_bundle.id == bundle_id).select(db.budget_bundle.name, limitby=(0, 1)).first().name
+table.quantity.label = T("Quantity")
+table.months.label = T("Months")
+
+table = db.budget_budget_staff
+table.budget_id.label = T("Budget")
+table.budget_id.represent = lambda budget_id: db(db.budget_budget.id == budget_id).select(db.budget_budget.name, limitby=(0, 1)).first().name
+#table.project_id.label = T("Project")
+#table.project_id.represent = lambda project_id: db(db.budget_project.id == project_id).select(db.budget_project.code, limitby=(0, 1)).first().code
+table.location_id.label = T("Location")
+table.location_id.represent = lambda location_id: db(db.budget_location.id == location_id).select(db.budget_location.code, limitby=(0, 1)).first().code
+table.staff_id.label = T("Staff")
+table.staff_id.represent = lambda bundle_id: db(db.budget_staff.id == staff_id).select(db.budget_staff.description, limitby=(0, 1)).first().description
+table.quantity.label = T("Quantity")
+table.months.label = T("Months")
+
+# S3 framework functions
+def index():
+    "Module's Home Page"
+
+    module_name = deployment_settings.modules[module].name_nice
+    response.title = module_name
+    return dict(module_name=module_name)
+
+def parameters():
+    "Select which page to go to depending on login status"
+    table = db.budget_parameter
+    authorised = s3_has_permission("update", table)
+    if authorised:
+        redirect (URL(r=request, f="parameter", args=[1, "update"]))
+    else:
+        redirect (URL(r=request, f="parameter", args=[1, "read"]))
+
+def parameter():
+
+    """ RESTful CRUD controller """
+
+    tablename = module + "_" + resourcename
+    table = db[tablename]
+
+    # Model Options
+    table.shipping.label = "Shipping cost"
+    table.logistics.label = "Procurement & Logistics cost"
+    table.admin.label = "Administrative support cost"
+    table.indirect.label = "Indirect support cost HQ"
+
+    # CRUD Strings
+    s3.crud_strings[tablename] = Storage(
+        title_update = T("Edit Parameters"),
+        title_display = T("Parameters"))
+
+    s3xrc.model.configure(table, deletable=False)
+    return s3_rest_controller(module, resourcename)
+
+def item():
+    """ RESTful CRUD controller """
+    tablename = module + "_" + resourcename
+    table = db[tablename]
+
+    # Model options used in multiple controllers so defined at the top of the file
+
+    # CRUD Strings
+    ADD_ITEM = T("Add Item")
+    LIST_ITEMS = T("List Items")
+    s3.crud_strings[tablename] = Storage(
+        title_create = ADD_ITEM,
+        title_display = T("Item Details"),
+        title_list = LIST_ITEMS,
+        title_update = T("Edit Item"),
+        title_search = T("Search Items"),
+        subtitle_create = T("Add New Item"),
+        subtitle_list = T("Items"),
+        label_list_button = LIST_ITEMS,
+        label_create_button = ADD_ITEM,
+        label_delete_button = T("Delete Item"),
+        label_search_button = T("Search Items"),
+        msg_record_created = T("Item added"),
+        msg_record_modified = T("Item updated"),
+        msg_record_deleted = T("Item deleted"),
+        msg_list_empty = T("No Items currently registered"))
+
+    response.s3.formats.pdf = URL(r=request, f="item_export_pdf")
+
+    s3xrc.model.configure(table,
+                          main="code",
+                          extra="description",
+                          orderby=db.budget_item.category_type)
+
+    return s3_rest_controller(module, resourcename)
+
+def item_export_pdf():
+    """
+    Export a list of Items in Adobe PDF format
+    Uses Geraldo Grouping Report
+    """
+    try:
+        from reportlab.lib.units import cm
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.enums import TA_CENTER, TA_RIGHT
+    except ImportError:
+        session.error = REPORTLAB_ERROR
+        redirect(URL(r=request, c="item"))
+    try:
+        from geraldo import Report, ReportBand, ReportGroup, Label, ObjectValue, SystemField, landscape, BAND_WIDTH
+        from geraldo.generators import PDFGenerator
+    except ImportError:
+        session.error = GERALDO_ERROR
+        redirect(URL(r=request, c="item"))
+
+    table = db.budget_item
+    objects_list = db(table.id > 0).select(orderby=table.category_type)
+    if not objects_list:
+        session.warning = T("No data in this table - cannot create PDF!")
+        redirect(URL(r=request, f="item"))
+
+    import StringIO
+    output = StringIO.StringIO()
+
+    class MyReport(Report):
+        def __init__(self, queryset=None, T=None):
+            " Initialise parent class & make any necessary modifications "
+            Report.__init__(self, queryset)
+            self.T = T
+        def _T(self, rawstring):
+            return self.T(rawstring)
+        # can't use T() here!
+        #title = _T("Items")
+        title = "Items"
+        page_size = landscape(A4)
+        class band_page_header(ReportBand):
+            height = 1.3*cm
+            elements = [
+                SystemField(expression="%(report_title)s", top=0.1*cm,
+                    left=0, width=BAND_WIDTH, style={"fontName": "Helvetica-Bold",
+                    "fontSize": 14, "alignment": TA_CENTER}
+                    ),
+                Label(text="Code", top=0.8*cm, left=0.2*cm),
+                Label(text="Description", top=0.8*cm, left=3*cm),
+                Label(text="Unit Cost", top=0.8*cm, left=13*cm),
+                Label(text="per Month", top=0.8*cm, left=15*cm),
+                Label(text="per Minute", top=0.8*cm, left=17*cm),
+                Label(text="per Megabyte", top=0.8*cm, left=19*cm),
+                Label(text="Comments", top=0.8*cm, left=21*cm),
+            ]
+            borders = {"bottom": True}
+        class band_page_footer(ReportBand):
+            height = 0.5*cm
+            elements = [
+                Label(text="%s" % request.utcnow.date(), top=0.1*cm, left=0),
+                SystemField(expression="Page # %(page_number)d of %(page_count)d", top=0.1*cm,
+                    width=BAND_WIDTH, style={"alignment": TA_RIGHT}),
+            ]
+            borders = {"top": True}
+        class band_detail(ReportBand):
+            height = 0.5*cm
+            auto_expand_height = True
+            elements = (
+                    ObjectValue(attribute_name="code", left=0.2*cm, width=2.8*cm),
+                    ObjectValue(attribute_name="description", left=3*cm, width=10*cm),
+                    ObjectValue(attribute_name="unit_cost", left=13*cm, width=2*cm),
+                    ObjectValue(attribute_name="monthly_cost", left=15*cm, width=2*cm),
+                    ObjectValue(attribute_name="minute_cost", left=17*cm, width=2*cm),
+                    ObjectValue(attribute_name="megabyte_cost", left=19*cm, width=2*cm),
+                    ObjectValue(attribute_name="comments", left=21*cm, width=6*cm),
+                    )
+        groups = [
+        ReportGroup(attribute_name="category_type",
+            band_header=ReportBand(
+                height=0.7*cm,
+                elements=[
+                    ObjectValue(attribute_name="category_type", left=0, top=0.1*cm,
+                        get_value=lambda instance: instance.category_type and budget_category_type_opts[instance.category_type],
+                        style={"fontName": "Helvetica-Bold", "fontSize": 12})
+                ],
+                borders={"bottom": True},
+            ),
+        ),
+    ]
+
+    #report = MyReport(queryset=objects_list)
+    report = MyReport(queryset=objects_list, T=T)
+    report.generate_by(PDFGenerator, filename=output)
+
+    output.seek(0)