def edit(self, key, **data):
"""Display an edit form for a record"""
c = self.collection
user = c.user
user.authorize('update', c)
record = locate(c, key)
if record:
user.authorize('read', record)
user.authorize('update', record)
c.fields.initialize(record)
c.fields.update(data)
form = form_for(c.fields, ButtonField('Save', cancel=record.url))
if c.verbose:
msg = '%s edited %s %s' % (
user.link,
c.link,
record.link,
)
log_activity(msg)
return page(form, title=c.item_title)
else:
return page('%s missing' % key)
def index(self, q=None):
def serializable(i):
_, v = i
try:
json.dumps(v)
return True
except TypeError:
return False
request = self.request
links = link_to('hello', '/hello')
tpl = links + '<pre>{}</pre>'
request_values = dict(filter(serializable, request.__dict__.items()))
values = dict(
request_values,
data=request.data,
a_url=url_for('howdy', name='Joe Smith'),
a_rooted_url=url_for('/howdy', name='Joe Smith'),
)
actions = 'New',
return page(tpl.format(json.dumps(values, indent=4)),
title='System Info',
actions=actions,
search=request.data.get('q', ''),
subtitle='this is the subtitle')
return page('overview', title='my page')
def process_reset_request(token, form):
if not valid_token(token):
return page(load_content('expired.md'))
tokens = get_tokens()
rec = tokens.first(token=token)
if rec:
user = context.site.users.first(email=rec.email)
if user:
filler = dict(
username=user.username,
first_name=user.first_name,
)
if context.user.is_admin:
form.update(
dict(
new_password='******',
confirm='somenewpassword',
)
)
content = load_content('reset.md', **filler) + form.edit()
return page(content)
else:
# no user by that email!
error('invalid request')
return redirect_to('/')
else:
error('invalid reset request')
return redirect_to('/')
def display_errors(request, handler, *rest):
"""Display errors for developers
"""
try:
return handler(request, *rest)
except zoom.exceptions.ThemeTemplateMissingException:
return zoom.response.HTMLResponse(
zoom.templates.template_missing
)
except Exception as e:
msg = traceback.format_exc()
logger = logging.getLogger(__name__)
logger.error(msg)
as_api = request.env.get('HTTP_ACCEPT', '') == 'application/json'
error_status = '500 Internal Server Error'
if not (hasattr(zoom.system, 'user') and zoom.system.user.is_admin):
if as_api:
return JSONResponse(
dict(status=error_status), status=error_status)
content = zoom.tools.load_template(
'friendly_error', zoom.templates.friendly_error)
return page(content, status=500).render(request)
content = """
<h2>Exception</h2>
{}
<h2>Request</h2>
<pre>{}</pre>
""".format(
html.pre(msg),
str(request),
)
if as_api:
return JSONResponse(
dict(
message=str(e),
status=error_status,
),
status=error_status
)
return page(
content,
title='Application Error',
status='500 Internal Server Error'
).render(request)
def index(self):
content = Component(
markdown("""
Parts
====
* <div class="component-pink">component styles makes this pink</div>
* <div class="component-green">component css makes this green</div>
* <div class="component-chocolate">component libs makes this chocolate</div>
* <div class="component-magenta">component js makes this magenta</div>
* <div class="component-coral">component head makes this coral</div>
* <div class="component-tomato">component tail makes this tomato</div>
* <div class="page-slategray">page styles makes this slategray</div>
* <div class="page-red">page css makes this red</div>
* <div class="page-purple">page libs makes this purple</div>
* <div class="page-cyan">page js makes this cyan</div>
* <div class="page-navy">page head makes this navy</div>
* <div class="page-olive">page tail makes this olive</div>
"""),
styles=['/sample/parts/mystyle'],
css=".component-green {color: green}",
libs=['/sample/parts/mylib'],
js='$(".component-magenta").css("color", "magenta")',
head='<style>.component-coral {color: coral}</style>',
tail=
'<script>$(".component-tomato").css("color", "tomato")</script>',
)
return page(
content,
styles=['/sample/parts/pagestyle'],
css='.page-red {color: red}',
libs=['/sample/parts/pagelib'],
js='$(".page-cyan").css("color", "cyan")',
head='<style>.page-navy {color: navy}</style>',
tail='<script>$(".page-olive").css("color", "olive")</script>',
)
def index(self, **kwargs):
"""show the settings form"""
values = self.settings.load()
values.update(kwargs)
self.form.initialize(values)
content = self.form.edit()
return page(content, title='Settings')
def entry(self, key):
def fmt(item):
name, value = item
return name, zoom.html.pre(value)
entries = zoom.table_of('log')
entry = list(entries.first(id=key).items())
visible = lambda a: not a[0].startswith('_')
content = zoom.html.table(map(fmt, filter(visible, entry)))
css = """
.content table {
width: 80%;
vertical-align: top;
}
.content table td:nth-child(1) {
width: 30%;
}
.content table td {
padding: 5px;
line-height: 20px;
}
.content table pre {
padding: 0px;
background: 0;
border: none;
line-height: 20px;
margin: 0;
}
"""
return page(content, title='Log Entry', css=css)
def index(self, email=None, submit_button=None):
if context.user.is_admin:
form.update(dict(email='*****@*****.**'))
content = load_content('index.md') + form.edit()
return page(content)
def table(self, name, limit='6'):
db = self.model.site.db
items = RecordStore(db, MyModel, name=name)
if len(items) == 1:
footer_name = 'record'
else:
footer_name = 'records'
footer = len(items) and '%s %s' % (len(items), footer_name) or ''
# If there is an id column we will use it to select the last N items,
# otherwise we'll just select the whole thing and then take what we
# want from the list.
columns = db.get_column_names(name)
limit = int(limit)
data = 'id' in columns and items[-limit:] or list(items)[-limit:]
content = browse(data, footer=footer, title='Sample Data')
if name in db.get_tables():
content += browse(db('describe ' + name), title='Structure')
if name in db.get_tables():
content += browse(db('show index from ' + name), title='Index')
database = db.database.name
if database:
content += browse(db(
'show table status in {} where name=%s'.format(database),
name),
title='Metadata')
return page(content, title='Record: ' + name)
def not_found(request):
"""return a 404 page for site"""
logger = logging.getLogger(__name__)
logger.debug('responding with 404 for {!r}'.format(request.path))
response = page(zoom.templates.page_not_found).render(request)
response.status = '404 Not Found'
return response
def environment(self):
return page(zoom.Component(
h.h2('Zoom'),
zoom.html.table([
('Version', zoom.__version__ + ' Community Edition'),
('Installed Path', zoom.tools.zoompath()),
]),
h.h2('Python'),
zoom.html.table([
('sys.version', sys.version),
('sys.path', '<br>'.join(sys.path)),
]),
h.h2('Operating System'),
zoom.html.table([
('Name', os.name),
('PATH', '<br>'.join(os.environ.get('PATH').split(':')))
]),
h.h2('Platform'),
zoom.html.table([('Node', platform.node()),
('System', platform.system()),
('Machine', platform.machine()),
('Archtitecture',
' '.join(platform.architecture()))]),
h.h2('Variables'),
zoom.html.table(list(os.environ.items())),
css="""
.content table { width: 100%; }
.content table td { vertical-align: top; width: 70%; }
.content table td:first-child { width: 25%; }
"""),
title='Environment')
def index(self):
footer = '{} records'.format(len(self.data))
content = component(
browse(self.data, title="Browse", footer=footer),
#browse(self.data, title="Table", footer=footer),
)
return page(content, title='Tables')
def environment(self):
return page(
zoom.Component(
h.h2('Python'),
zoom.tags.table([
('Version', sys.version),
('PYTHONPATH', '<br>'.join(sys.path)),
('PATH', '<br>'.join(os.environ.get('PATH').split(':')))
]),
h.h2('Operating System'),
zoom.tags.table([
('Name', os.name),
('PYTHONPATH', '<br>'.join(sys.path)),
('PATH', '<br>'.join(os.environ.get('PATH').split(':')))
]),
h.h2('Platform'),
zoom.tags.table([
('Node', platform.node()),
('System', platform.system()),
('Machine', platform.machine()),
('Archtitecture', ' '.join(platform.architecture()))
]),
h.h2('Variables'),
zoom.tags.table(
list(os.environ.items())
),
css = """
.content table { width: 100%; }
.content table td { vertical-align: top; }
"""
),
title='Environment'
)
def compose(self):
# print(context.site)
return page(content='Send mail as "{} <{}>"<br><br>{}'.format(
context.site.mail_from_name,
context.site.mail_from_addr,
mail_form.edit(),
), title='Send Mail')
def requests(self, show_all=False):
def fmt(rec):
entry = (link_to(str(rec[0]), '/admin/entry/' + str(rec[0])), )
user = (zoom.helpers.who(rec[4]), )
link = (zoom.link_to(rec[2]), )
return entry + (rec[1], ) + link + rec[3:4] + user + rec[5:]
path_filter = '' if show_all else 'and path not like "%%\\/\\_%%"'
db = self.model.site.db
data = db(
"""
select
id, app, path, status, user_id, address, login, timestamp, elapsed
from log
where status in ('C', 'I', 'W')
and server = %s
{}
order by id desc
limit 100""".format(path_filter), zoom.system.request.host)
labels = 'id', 'app', 'path', 'status', 'user', 'address', 'login', 'timestamp', 'elapsed'
data = list(map(fmt, data))
actions = () if show_all else ('Show All', )
return page(zoom.browse(data, labels=labels),
title='Requests',
actions=actions)
def display_errors(request, handler, *rest):
"""Display errors for developers
>>> request = zoom.request.build('http://localhost')
>>> request.app = zoom.utils.Bunch(theme='default', templates_paths=[])
>>> request.host = 'localhost'
>>> request.site = zoom.sites.Site()
>>> request.site.theme = 'default'
>>> request.site.request = request
>>> zoom.system.request = request
>>> zoom.system.site = request.site
>>> zoom.system.user = request.site.users.first(username='******')
>>> zoom.system.user.is_admin = True
>>> def throw(request):
... raise Exception('ouch!')
>>> response = display_errors(request, throw)
>>> isinstance(response, HTMLResponse)
True
>>> zoom.system.user.is_admin = False
>>> response = display_errors(request, throw)
>>> isinstance(response, HTMLResponse)
True
"""
try:
return handler(request, *rest)
except Exception:
msg = traceback.format_exc()
logger = logging.getLogger(__name__)
logger.error(msg)
if not (hasattr(zoom.system, 'user') and zoom.system.user.is_admin):
content = zoom.tools.load_template('friendly_error',
zoom.templates.friendly_error)
return page(content).render(request)
content = """
<h2>Exception</h2>
{}
<h2>Request</h2>
<pre>{}</pre>
""".format(
html.pre(msg),
str(request),
)
return page(content, title='Application Error').render(request)
def entity(self, name):
items = EntityStore(self.model.site.db, MyModel, kind=name)
if len(items) == 1:
footer_name = 'record'
else:
footer_name = 'records'
footer = len(items) and '%s %s' % (len(items), footer_name) or ''
return page(browse(items, footer=footer), title='Entity: ' + name)
def stdout(self):
print('Here is some stdout output!')
msg = """
stdout output
<br><br>
<a href="<dz:parent_path>">Go Back</a>
"""
return page(msg, title='Stdout')
def edit(self, key=None, *a, **k):
site = self.model.site
# path = os.path.join(site.data_path, 'buckets')
# bucket = Bucket(path)
form1.update(sample)
form1.update(k)
content = form1.edit()
return page(content, actions=actions, title='Edit Mode')
def show_error(self, key):
db = self.model.site.db
log_entry = db('select * from log where id=%s', key).first()
content = '<br><br>'.join(map(str, log_entry)).replace(
'\n', '<br>'
)
return page(content, title='Log Entry')
def new(self, *args, **kwargs):
"""Return a New Item form"""
c = self.collection
c.user.authorize('create', c)
if kwargs:
c.fields.validate(kwargs)
form = form_for(c.fields, ButtonField('Create', cancel=c.url))
return page(form, title='New '+c.item_title)
def audit(self):
db = self.model.site.db
log_data = db("""
select *
from audit_log
order by timestamp desc
limit 100""")
return page(browse(log_data), title='Activity')
def log(self):
"""view system log"""
save_logging = self.model.site.logging
try:
content = callback(self._system_log)
finally:
self.model.site.logging = save_logging
return page(content, title='System Log')
def activity(self):
db = self.model.site.db
log_data = db("""
select *
from log
where status in ('A')
order by timestamp desc, id desc
limit 100""")
return page(browse(log_data), title='Activity')
def requests(self):
db = self.model.site.db
log_data = db("""
select *
from log
where status in ('C', 'I')
order by timestamp desc
limit 100""")
return page(browse(log_data), title='Requests')
def configuration(self):
items = zoom.packages.get_registered_packages()
packages = '<dt>combined</dt><dd>{}</dd>'.format(
zoom.html.pre(json.dumps(items, indent=4, sort_keys=True)))
return page(
load_content('configuration.md').format(
request=self.model,
packages=packages,
))
def show(self, path=None):
template = 'default'
if path == None or path == 'content/index.html':
path = ''
template = 'index'
else:
path = '/'.join(path.split('/')[1:])
content = load_page(path)
if content:
return page(content, template=template)
def entity(self, name, limit=20):
items = EntityStore(self.model.site.db, MyModel, kind=name)
limit = int(limit)
count = len(items)
if count == 1:
footer_name = 'record'
else:
footer_name = 'records'
footer = count and '%s %s' % (count, footer_name) or ''
if count > limit:
items = items[-limit:] # most recent 100
return page(browse(items, footer=footer), title='Entity: ' + name)
def queue(self, name):
items = self.model.site.queues.topic(name, -1)
items = [(n, repr(x)) for n, x in enumerate(items)]
if len(items) == 1:
footer_name = 'message'
else:
footer_name = 'messages'
footer = len(items) and '%s %s' % (len(items), footer_name) or ''
return page(browse(items,
labels=('Position', 'Message'),
footer=footer),
title='Topic: ' + name)
def index(self):
content = markdown("""
Alerts
====
* [Success](alerts/success)
* [Warning](alerts/warning)
* [Error](alerts/error)
* [Random](alerts/random)
Developer
====
* [Stdout](alerts/stdout)
""")
return page(content)
def index(self, *a, **k):
username = k.get('username', '')
user = self.model.user
referrer_url = k.get('referrer')
if referrer_url:
referrer = html.hidden(
id="referrer",
name="referrer",
value=referrer_url,
)
else:
referrer = ''
form = LoginForm(username=username, user=user, referrer=referrer)
return page(form)
