def widget(field, value, download_url=None, **attributes):
"""
generates a INPUT file tag.
Optionally provides an A link to the file, including a checkbox so
the file can be deleted.
All is wrapped in a DIV.
see also: :meth:`FormWidget.widget`
:param download_url: Optional URL to link to the file (default = None)
"""
default = dict(_type='file', )
attr = UploadWidget._attributes(field, default, **attributes)
inp = INPUT(**attr)
if download_url and value:
url = download_url + '/' + value
(br, image) = ('', '')
if UploadWidget.is_image(value):
br = BR()
image = IMG(_src=url, _width=UploadWidget.DEFAULT_WIDTH)
inp = DIV(
inp, '[', A(UploadWidget.GENERIC_DESCRIPTION, _href=url), '|',
INPUT(_type='checkbox',
_name=field.name + UploadWidget.ID_DELETE_SUFFIX),
'delete]', br, image)
return inp
def toolbar(self):
from html import DIV, SCRIPT, BEAUTIFY, TAG, URL, A
BUTTON = TAG.button
admin = URL("admin",
"default",
"design",
args=current.request.application)
from gluon.dal import THREAD_LOCAL
if hasattr(THREAD_LOCAL, 'instances'):
dbstats = [TABLE(*[TR(PRE(row[0]),'%.2fms' % (row[1]*1000)) \
for row in i.db._timings]) \
for i in THREAD_LOCAL.instances]
dbtables = dict([(regex_nopasswd.sub('******', i.uri), {
'defined':
sorted(list(set(i.db.tables) - set(i.db._LAZY_TABLES.keys())))
or '[no defined tables]',
'lazy':
sorted(i.db._LAZY_TABLES.keys()) or '[no lazy tables]'
}) for i in THREAD_LOCAL.instances])
else:
dbstats = [] # if no db or on GAE
dbtables = {}
u = web2py_uuid()
backtotop = A('Back to top', _href="#totop-%s" % u)
return DIV(BUTTON('design', _onclick="document.location='%s'" % admin),
BUTTON('request',
_onclick="jQuery('#request-%s').slideToggle()" % u),
BUTTON('response',
_onclick="jQuery('#response-%s').slideToggle()" % u),
BUTTON('session',
_onclick="jQuery('#session-%s').slideToggle()" % u),
BUTTON('db tables',
_onclick="jQuery('#db-tables-%s').slideToggle()" %
u),
BUTTON('db stats',
_onclick="jQuery('#db-stats-%s').slideToggle()" % u),
DIV(BEAUTIFY(current.request),
backtotop,
_class="hidden",
_id="request-%s" % u),
DIV(BEAUTIFY(current.session),
backtotop,
_class="hidden",
_id="session-%s" % u),
DIV(BEAUTIFY(current.response),
backtotop,
_class="hidden",
_id="response-%s" % u),
DIV(BEAUTIFY(dbtables),
backtotop,
_class="hidden",
_id="db-tables-%s" % u),
DIV(BEAUTIFY(dbstats),
backtotop,
_class="hidden",
_id="db-stats-%s" % u),
SCRIPT("jQuery('.hidden').hide()"),
_id="totop-%s" % u)
def toolbar(self):
from html import DIV, SCRIPT, BEAUTIFY, TAG, URL, A
BUTTON = TAG.button
admin = URL("admin",
"default",
"design",
args=current.request.application)
from gluon.dal import DAL
dbstats = []
dbtables = {}
infos = DAL.get_instances()
for k, v in infos.iteritems():
dbstats.append(
TABLE(*[
TR(PRE(row[0]), '%.2fms' % (row[1] * 1000))
for row in v['dbstats']
]))
dbtables[k] = dict(defined=v['dbtables']['defined']
or '[no defined tables]',
lazy=v['dbtables']['lazy']
or '[no lazy tables]')
u = web2py_uuid()
backtotop = A('Back to top', _href="#totop-%s" % u)
return DIV(BUTTON('design', _onclick="document.location='%s'" % admin),
BUTTON('request',
_onclick="jQuery('#request-%s').slideToggle()" % u),
BUTTON('response',
_onclick="jQuery('#response-%s').slideToggle()" % u),
BUTTON('session',
_onclick="jQuery('#session-%s').slideToggle()" % u),
BUTTON('db tables',
_onclick="jQuery('#db-tables-%s').slideToggle()" %
u),
BUTTON('db stats',
_onclick="jQuery('#db-stats-%s').slideToggle()" % u),
DIV(BEAUTIFY(current.request),
backtotop,
_class="hidden",
_id="request-%s" % u),
DIV(BEAUTIFY(current.session),
backtotop,
_class="hidden",
_id="session-%s" % u),
DIV(BEAUTIFY(current.response),
backtotop,
_class="hidden",
_id="response-%s" % u),
DIV(BEAUTIFY(dbtables),
backtotop,
_class="hidden",
_id="db-tables-%s" % u),
DIV(BEAUTIFY(dbstats),
backtotop,
_class="hidden",
_id="db-stats-%s" % u),
SCRIPT("jQuery('.hidden').hide()"),
_id="totop-%s" % u)
def represent(field, value, download_url=None):
"""
how to represent the file:
- with download url and if it is an image: <A href=...><IMG ...></A>
- otherwise with download url: <A href=...>file</A>
- otherwise: file
:param field: the field
:param value: the field value
:param download_url: url for the file download (default = None)
"""
inp = UploadWidget.GENERIC_DESCRIPTION
if download_url and value:
url = download_url + '/' + value
if UploadWidget.is_image(value):
inp = IMG(_src=url, _width=UploadWidget.DEFAULT_WIDTH)
inp = A(inp, _href=url)
return inp
def __init__(self,
table,
record=None,
deletable=False,
linkto=None,
upload=None,
fields=None,
labels=None,
col3={},
submit_button='Submit',
delete_label='Check to delete:',
showid=True,
readonly=False,
comments=True,
keepopts=[],
ignore_rw=False,
record_id=None,
formstyle='table3cols',
**attributes):
"""
SQLFORM(db.table,
record=None,
fields=['name'],
labels={'name': 'Your name'},
linkto=URL(r=request, f='table/db/')
"""
self.ignore_rw = ignore_rw
self.formstyle = formstyle
nbsp = XML(' ') # Firefox2 does not display fields with blanks
FORM.__init__(self, *[], **attributes)
ofields = fields
keyed = hasattr(table, '_primarykey')
# if no fields are provided, build it from the provided table
# will only use writable or readable fields, unless forced to ignore
if fields == None:
fields = [
f.name for f in table
if (ignore_rw or f.writable or f.readable) and not f.compute
]
self.fields = fields
# make sure we have an id
if self.fields[0] != table.fields[0] and \
isinstance(table,Table) and not keyed:
self.fields.insert(0, table.fields[0])
self.table = table
# try to retrieve the indicated record using its id
# otherwise ignore it
if record and isinstance(record, (int, long, str, unicode)):
if not str(record).isdigit():
raise HTTP(404, "Object not found")
record = table._db(table.id == record).select().first()
if not record:
raise HTTP(404, "Object not found")
self.record = record
self.record_id = record_id
if keyed:
if record:
self.record_id = dict([(k, record[k])
for k in table._primarykey])
else:
self.record_id = dict([(k, None) for k in table._primarykey])
self.field_parent = {}
xfields = []
self.fields = fields
self.custom = Storage()
self.custom.dspval = Storage()
self.custom.inpval = Storage()
self.custom.label = Storage()
self.custom.comment = Storage()
self.custom.widget = Storage()
self.custom.linkto = Storage()
for fieldname in self.fields:
if fieldname.find('.') >= 0:
continue
field = self.table[fieldname]
comment = None
if comments:
comment = col3.get(fieldname, field.comment)
if comment == None:
comment = ''
self.custom.comment[fieldname] = comment
if labels != None and fieldname in labels:
label = labels[fieldname]
colon = ''
else:
label = field.label
colon = ': '
self.custom.label[fieldname] = label
field_id = '%s_%s' % (table._tablename, fieldname)
label = LABEL(label,
colon,
_for=field_id,
_id=field_id + SQLFORM.ID_LABEL_SUFFIX)
row_id = field_id + SQLFORM.ID_ROW_SUFFIX
if field.type == 'id':
self.custom.dspval.id = nbsp
self.custom.inpval.id = ''
widget = ''
if record:
if showid and 'id' in fields and field.readable:
v = record['id']
widget = SPAN(v, _id=field_id)
self.custom.dspval.id = str(v)
xfields.append((row_id, label, widget, comment))
self.record_id = str(record['id'])
self.custom.widget.id = widget
continue
if readonly and not ignore_rw and not field.readable:
continue
if record:
default = record[fieldname]
else:
default = field.default
cond = readonly or \
(not ignore_rw and not field.writable and field.readable)
if default and not cond:
default = field.formatter(default)
dspval = default
inpval = default
if cond:
# ## if field.represent is available else
# ## ignore blob and preview uploaded images
# ## format everything else
if field.represent:
inp = field.represent(default)
elif field.type in ['blob']:
continue
elif field.type == 'upload':
inp = UploadWidget.represent(field, default, upload)
else:
inp = field.formatter(default)
elif hasattr(field, 'widget') and field.widget:
inp = field.widget(field, default)
elif field.type == 'upload':
inp = self.widgets.upload.widget(field, default, upload)
elif field.type == 'boolean':
inp = self.widgets.boolean.widget(field, default)
if default:
inpval = 'checked'
else:
inpval = ''
elif OptionsWidget.has_options(field):
if not field.requires.multiple:
inp = self.widgets.options.widget(field, default)
else:
inp = self.widgets.multiple.widget(field, default)
if fieldname in keepopts:
inpval = TAG[''](*inp.components)
elif str(field.type).startswith('list'):
inp = self.widgets.list.widget(field, default)
elif field.type == 'text':
inp = self.widgets.text.widget(field, default)
elif field.type == 'password':
inp = self.widgets.password.widget(field, default)
if self.record:
dspval = PasswordWidget.DEFAULT_PASSWORD_DISPLAY
else:
dspval = ''
elif field.type == 'blob':
continue
else:
inp = self.widgets.string.widget(field, default)
xfields.append((row_id, label, inp, comment))
self.custom.dspval[fieldname] = dspval or nbsp
self.custom.inpval[fieldname] = inpval or ''
self.custom.widget[fieldname] = inp
# if a record is provided and found, as is linkto
# build a link
if record and linkto:
for (rtable, rfield) in table._referenced_by:
if keyed:
rfld = table._db[rtable][rfield]
query = urllib.quote(
str(rfld == record[rfld.type[10:].split('.')[1]]))
else:
# <block>
query = urllib.quote(
str(table._db[rtable][rfield] == record.id))
lname = olname = '%s.%s' % (rtable, rfield)
if ofields and not olname in ofields:
continue
if labels and lname in labels:
lname = labels[lname]
widget = A(lname,
_class='reference',
_href='%s/%s?query=%s' % (linkto, rtable, query))
xfields.append(
(olname.replace('.', '__') + SQLFORM.ID_ROW_SUFFIX, '',
widget, col3.get(olname, '')))
self.custom.linkto[olname.replace('.', '__')] = widget
# </block>
# when deletable, add delete? checkbox
self.custom.deletable = ''
if record and deletable:
widget = INPUT(
_type='checkbox',
_class='delete',
_id=self.FIELDKEY_DELETE_RECORD,
_name=self.FIELDNAME_REQUEST_DELETE,
)
xfields.append(
(self.FIELDKEY_DELETE_RECORD + SQLFORM.ID_ROW_SUFFIX,
LABEL(delete_label,
_for=self.FIELDKEY_DELETE_RECORD,
_id=self.FIELDKEY_DELETE_RECORD +
SQLFORM.ID_LABEL_SUFFIX), widget,
col3.get(self.FIELDKEY_DELETE_RECORD, '')))
self.custom.deletable = widget
# when writable, add submit button
self.custom.submit = ''
if not readonly:
widget = INPUT(_type='submit', _value=submit_button)
xfields.append(
('submit_record' + SQLFORM.ID_ROW_SUFFIX, '', widget,
col3.get('submit_button', '')))
self.custom.submit = widget
# if a record is provided and found
# make sure it's id is stored in the form
if record:
if not self['hidden']:
self['hidden'] = {}
if not keyed:
self['hidden']['id'] = record['id']
(begin, end) = self._xml()
self.custom.begin = XML("<%s %s>" % (self.tag, begin))
self.custom.end = XML("%s</%s>" % (end, self.tag))
if formstyle == 'table3cols':
table = TABLE()
for id, a, b, c in xfields:
td_b = self.field_parent[id] = TD(b, _class='w2p_fw')
table.append(
TR(TD(a, _class='w2p_fl'),
td_b,
TD(c, _class='w2p_fc'),
_id=id))
elif formstyle == 'table2cols':
table = TABLE()
for id, a, b, c in xfields:
td_b = self.field_parent[id] = TD(b,
_class='w2p_fw',
_colspan="2")
table.append(
TR(TD(a, _class='w2p_fl'),
TD(c, _class='w2p_fc'),
_id=id + '1',
_class='even'))
table.append(TR(td_b, _id=id + '2', _class='odd'))
elif formstyle == 'divs':
table = TAG['']()
for id, a, b, c in xfields:
div_b = self.field_parent[id] = DIV(b, _class='w2p_fw')
table.append(
DIV(DIV(a, _class='w2p_fl'),
div_b,
DIV(c, _class='w2p_fc'),
_id=id))
elif formstyle == 'ul':
table = UL()
for id, a, b, c in xfields:
div_b = self.field_parent[id] = DIV(b, _class='w2p_fw')
table.append(
LI(DIV(a, _class='w2p_fl'),
div_b,
DIV(c, _class='w2p_fc'),
_id=id))
elif type(formstyle) == type(lambda: None):
table = TABLE()
for id, a, b, c in xfields:
td_b = self.field_parent[id] = TD(b, _class='w2p_fw')
newrows = formstyle(id, a, td_b, c)
if type(newrows).__name__ != "tuple":
newrows = [newrows]
for newrow in newrows:
table.append(newrow)
else:
raise RuntimeError, 'formsyle not supported'
self.components = [table]
def __init__(self,
sqlrows,
linkto=None,
upload=None,
orderby=None,
headers={},
truncate=16,
columns=None,
th_link='',
**attributes):
TABLE.__init__(self, **attributes)
self.components = []
self.attributes = attributes
self.sqlrows = sqlrows
(components, row) = (self.components, [])
if not columns:
columns = sqlrows.colnames
if headers == 'fieldname:capitalize':
headers = {}
for c in columns:
headers[c] = ' '.join(
[w.capitalize() for w in c.split('.')[-1].split('_')])
for c in columns:
if orderby:
row.append(
TH(A(headers.get(c, c), _href=th_link + '?orderby=' + c)))
else:
row.append(TH(headers.get(c, c)))
components.append(THEAD(TR(*row)))
tbody = []
for (rc, record) in enumerate(sqlrows):
row = []
if rc % 2 == 0:
_class = 'even'
else:
_class = 'odd'
for colname in columns:
if not table_field.match(colname):
r = record._extra[colname]
row.append(TD(r))
continue
(tablename, fieldname) = colname.split('.')
field = sqlrows.db[tablename][fieldname]
if tablename in record \
and isinstance(record,Row) \
and isinstance(record[tablename],Row):
r = record[tablename][fieldname]
elif fieldname in record:
r = record[fieldname]
else:
raise SyntaxError, 'something wrong in Rows object'
r_old = r
if field.represent:
r = field.represent(r)
elif field.type == 'blob' and r:
r = 'DATA'
elif field.type == 'upload':
if upload and r:
r = A('file', _href='%s/%s' % (upload, r))
elif r:
r = 'file'
else:
r = ''
elif field.type in ['string', 'text']:
r = str(field.formatter(r))
ur = unicode(r, 'utf8')
if truncate != None and len(ur) > truncate:
r = ur[:truncate - 3].encode('utf8') + '...'
elif linkto and field.type == 'id':
try:
href = linkto(r, 'table', tablename)
except TypeError:
href = '%s/%s/%s' % (linkto, tablename, r_old)
r = A(r, _href=href)
elif linkto and str(field.type).startswith('reference'):
ref = field.type[10:]
try:
href = linkto(r, 'reference', ref)
except TypeError:
href = '%s/%s/%s' % (linkto, ref, r_old)
if ref.find('.') >= 0:
tref, fref = ref.split('.')
if hasattr(sqlrows.db[tref], '_primarykey'):
href = '%s/%s?%s' % (
linkto, tref, urllib.urlencode({fref: ur}))
r = A(r, _href=href)
elif linkto and hasattr(
field._table, '_primarykey'
) and fieldname in field._table._primarykey:
# have to test this with multi-key tables
key = urllib.urlencode(dict( [ \
((tablename in record \
and isinstance(record, Row) \
and isinstance(record[tablename], Row)) and
(k, record[tablename][k])) or (k, record[k]) \
for k in field._table._primarykey ] ))
r = A(r, _href='%s/%s?%s' % (linkto, tablename, key))
row.append(TD(r))
tbody.append(TR(_class=_class, *row))
components.append(TBODY(*tbody))