so, I'm looking... still can't see why I get a new row as opposed to
an updated one... Obviously, I am doing something wrong, but can't see
it. I'm thinking that the corresponding user ID has to be pre-
populated? Then again, maybe not... do I need to get the target
table's row ID before I submit and force it to work on that row
instead of creating a new one?
Thanks,
Mart :)
On Sep 27, 12:59 pm, mart <msenecal...@gmail.com> wrote:
> 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()
>
> ...
>
> read more »
