You are very correct, my row is None (and I should have checked this
before sending all those lines of sad looking code ;) )
row:
None
Thanks,
Mart :)
On Sep 27, 12:53 pm, mart <msenecal...@gmail.com> wrote:
> here I go (hope there is enough room here...), and yes, I know it
> looks sad ;):
>
> Controller:
>
> ## -*- coding: utf-8 -*-
>
> #########################################################################
> ## This is a samples controller
> ## - index is the default action of any application
> ## - user is required for authentication and authorization
> ## - download is for downloading files uploaded in the db (does
> streaming)
> ## - call exposes all registered services (none by default)
> #########################################################################
>
> import os, sys, string, re
> from collections import deque
>
> @auth.requires_login()
> def index():
> """
> example action using the internationalization operator T and flash
> rendered by views/default/index.html or views/generic.html
> """
> #response.flash = T('P4 user account cleanup!')
>
> return dict()
>
> @auth.requires_login()
> def test():
> return(dict)
>
> def data():
> return dict(form=crud())
>
> '''
> def populateP4Users():
> # proposed list to start -> suspect MANY more to come
> non_active_list = [
> 'benoit.nadeau',
> 'bernard.sjiariel',
> 'binh.dang',
> 'bulucc',
> 'craigt',
> 'davidk',
> 'gabriels',
> 'kevin',
> 'kyans',
> 'max',
> 'mikem',
> 'nam.phan',
> 'nguyen.tran',
> 'nirbhay.vashi',
> 'rachel',
> 'rachelv',
> 'reuben',
> 'ron.prior',
> 'sanamm',
> 'sang.vo',
> 'thinh.phan',
> 'tom.zhang',
> 'trang.mai',
> 'van.nguyen',
> 'vesna.cakarevic',
> 'will',
> 'yosef',
> 'yuehuay'
> ]
>
> form = SQLFORM(db.p4users)
> if form.accepts(request.vars, session, dbio=False):
> response.flash = T('in populateP4Users!')
> f = open('./p4users.txt', 'r')
> users = f.readlines()
> f.close()
> uInfo = deque()
> garbageList = deque()
> for user in users:
> uDictList = {}
> one = string.split(user, '<')
> if one:
> p4UserStatus = None
> strP4_user = string.strip(one[0])
> two = string.split(one[1],'>')
> strMail = string.strip(two[0])
> three = string.split(two[1],'(')
> four = string.split(user, '(')
> [1]
> strName = string.split(four,')')[0]
> last_accessDate = string.split(three[1],')')[1]
> date = string.split(last_accessDate,'accessed')[1]
> strAccessed = string.strip(date,'\\n')
> if not 'tao' in user or not 'error:' in user:
> if strP4_user in non_active_list:
> p4UserStatus = 1
>
> db.p4users.insert(p4_user=strP4_user,mail=strMail,p4_name=strName,accessed=strAccessed,p4status=p4UserStatus)
>
> SQLFORM(table, record=None, deletable=False,
> linkto=None, upload=None, fields=None, labels=None, col3={},
> submit_button='Submit', delete_label='Check to delete:',
> id_label='Record id: ', showid=True,
> readonly=False, comments=True, keepopts=[],
> ignore_rw=False, formstyle='table3cols',**attributes)
>
> '''
> def update_user():
> form = SQLFORM(db.p4users_all,record)
> if form.accepts(request.vars, session, dbio=False):
> if form.vars.get('delete_this_record', False):
> db(db.person.id==record.id).delete()
> else:
> record.update_record(**dict(form.vars))
> response.flash = 'record updated'
>
> def edit():
> row = db.p4users_all[request.args(0)]
> form = SQLFORM(db.p4users_all, row, deletable=True)
> if form.accepts(request.vars, session):
> response.flash = 'record updated'
> return dict(form=form)
>
> def display_form():
> # record = db.p4users_all(request.args(0))
> row = db.p4users_all[request.args(0)]
> form = SQLFORM(db.p4users_all, row, deletable=True)
> form.vars.id = request.vars.id
> if form.accepts(request.vars, session):
>
> response.flash = 'form accepted'
> elif form.errors:
> response.flash = 'form has errors'
> return dict(form=form)
>
> def countUsers():
> pass # will do this later -> for pie chart
>
> '''
>
> didn't work out -> page for for update wasn't 'pretty'
> '''
> @auth.requires_login()
> def p4():
> grid = webgrid.WebGrid(crud)
> grid.crud_function = 'data'
> grid.datasource = db(db.p4users.p4status==db.p4Status.id)
> grid.pagesize = 200
> grid.fields = ['p4users.id',
> 'p4users.p4_user',
> 'p4users.mail',
> 'p4users.p4_name',
> 'p4users.accessed',
> 'p4users.p4status',
> 'p4users.license_status',
> 'p4users.comments']
> # grid.filters =
> ['summitTrackableItems.responsible','summitTrackableItems.status']
> grid.filters = ['p4users.p4status']
> grid.filter_query = lambda f, v: f >= v
> return dict(grid=grid())
>
> def user():
> """
> exposes:
> http://..../[app]/default/user/login
> http://..../[app]/default/user/logout
> http://..../[app]/default/user/register
> http://..../[app]/default/user/profile
> http://..../[app]/default/user/retrieve_password
> http://..../[app]/default/user/change_password
> use @auth.requires_login()
> @auth.requires_membership('group name')
> @auth.requires_permission('read','table name',record_id)
> to decorate functions that need access control
> """
> return dict(form=auth())
>
> def download():
> """
> allows downloading of uploaded files
> http://..../[app]/default/download/[filename]
> """
> return response.download(request,db)
>
> def call():
> """
> exposes services. for example:
> http://..../[app]/default/call/jsonrpc
> decorate with @services.jsonrpc the functions to expose
> supports xml, json, xmlrpc, jsonrpc, amfrpc, rss, csv
> """
> session.forget()
> return service()
>
> Model:
>
> # -*- coding: utf-8 -*-
>
> #########################################################################
> ## This scaffolding model makes your app work on Google App Engine too
> #########################################################################
>
> if request.env.web2py_runtime_gae: # if running on Google
> App Engine
> db = DAL('gae') # connect to Google
> BigTable
> session.connect(request, response, db = db) # and store sessions
> and tickets there
> ### or use the following lines to store sessions in Memcache
> # from gluon.contrib.memdb import MEMDB
> # from google.appengine.api.memcache import Client
> # session.connect(request, response, db = MEMDB(Client()))
> else: # else use a normal
> relational database
> db = DAL('sqlite://storage.sqlite') # if not, use SQLite or
> other DB
> ## if no need for session
> # session.forget()
>
> #########################################################################
> ## Here is sample code if you need for
> ## - email capabilities
> ## - authentication (registration, login, logout, ... )
> ## - authorization (role based authorization)
> ## - services (xml, csv, json, xmlrpc, jsonrpc, amf, rss)
> ## - crud actions
> ## (more options discussed in gluon/tools.py)
> #########################################################################
>
> from gluon.tools import *
> mail = Mail() # mailer
> auth = Auth(globals(),db) # authentication/
> authorization
> crud = Crud(globals(),db) # for CRUD helpers
> using auth
> service = Service(globals()) # for json, xml,
> jsonrpc, xmlrpc, amfrpc
> plugins = PluginManager()
>
> mail.settings.server = 'logging' or 'smtp.gmail.com:587' # your SMTP
> server
> mail.settings.sender = '....@gmail.com' # your email
> mail.settings.login = 'username:password' # your credentials or
> None
>
> auth.settings.hmac_key =
> 'sha512:15cd54c5-8b0a-400d-8a39-6bf56b40696a' # before
> define_tables()
> auth.define_tables() # creates all needed
> tables
> auth.settings.mailer = mail # for user email
> verification
> auth.settings.registration_requires_verification = False
> auth.settings.registration_requires_approval = False
> auth.messages.verify_email = 'Click on the link
> http://'+request.env.http_host+URL(r=request,c='default',f='user',args=['verify_email'])+'/%(key)s
> to verify your email'
> auth.settings.reset_password_requires_verification = True
> auth.messages.reset_password = 'Click on the link
> http://'+request.env.http_host+URL(r=request,c='default',f='user',args=['reset_password'])+'/%(key)s
> to reset your password'
>
> #########################################################################
> ## If you need to use OpenID, Facebook, MySpace, Twitter, Linkedin,
> etc.
> ## register with janrain.com, uncomment and customize following
> # from gluon.contrib.login_methods.rpx_account import RPXAccount
> #
> auth.settings.actions_disabled=['register','change_password','request_reset_password']
> # auth.settings.login_form = RPXAccount(request,
> api_key='...',domain='...',
> # url = "http://localhost:8000/%s/default/user/login"; %
> request.application)
> ## other login methods are...
>
> read more »
