def users_panel(db):
host = zoom.system.request.host
data = db(
"""
select
users.username,
max(log.timestamp) as timestamp,
count(*) as requests
from log, users
where log.user_id = users.id
and timestamp >= %s
and server = %s
and path not like "%%\\/\\_%%"
group by users.username
order by timestamp desc
limit 10
""",
today() - datetime.timedelta(days=14), host)
rows = []
for rec in data:
row = [
link_to_user(rec[0]),
how_long_ago(rec[1]),
rec[2],
]
rows.append(row)
labels = 'user', 'last seen', 'requests'
return zoom.browse(rows, labels=labels, title=link_to_page('Users'))
def error_panel(db):
host = zoom.system.request.host
data = db(
"""
select
log.id,
username,
path,
timestamp
from log left join users on log.user_id = users.id
where log.status in ("E") and timestamp>=%s
and server = %s
order by log.id desc
limit 10
""", today(), host)
rows = []
for rec in data:
row = [
link_to(str(rec[0]), '/admin/entry/' + str(rec[0])),
link_to_user(rec[1]),
rec[2],
how_long_ago(rec[3]),
]
rows.append(row)
labels = 'id', 'user', 'path', 'when'
return zoom.browse(rows, labels=labels, title=link_to_page('Errors'))
def activity_panel(db):
host = zoom.system.request.host
data = db(
"""
select
log.id,
users.username,
log.address,
log.path,
log.timestamp,
log.elapsed
from log left join users on log.user_id = users.id
where server = %s and path not like "%%\\/\\_%%"
and log.status = 'C'
order by timestamp desc
limit 15
""", host)
rows = []
for rec in data:
row = [
link_to(str(rec[0]), '/admin/entry/' + str(rec[0])),
link_to_user(rec[1]),
rec[2],
zoom.link_to(rec[3]),
how_long_ago(rec[4]),
rec[4],
rec[5],
]
rows.append(row)
labels = 'id', 'user', 'address', 'path', 'when', 'timestamp', 'elapsed'
return zoom.browse(rows, labels=labels, title=link_to_page('Requests'))
def index(self):
def get_group_link(group_id):
"""Return a group link"""
group = groups.get(group_id)
return group.link if group else zoom.html.span(
'missing', title='unknown subgroup id {!r}'.format(group_id))
def fmt(app):
"""Format an app record"""
name = app.name
group_name = 'a_' + app.name
app_group = zoom.system.site.groups.first(name=group_name)
groups = ', '.join(
get_group_link(s) for g, s in subgroups
if g == app_group._id) or 'none' if app_group else ''
return [
app.title, app.name, app.path, groups,
(bool(app.in_development) and 'development' or '')
]
db = zoom.system.site.db
subgroups = list(db('select * from subgroups'))
groups = dict((g.group_id, g) for g in zoom.system.site.groups)
data = [
fmt(app) for app in sorted(zoom.system.site.apps,
key=lambda a: a.title.lower())
]
content = zoom.browse(
data, labels=['Title', 'App', 'Path', 'Groups', 'Status'])
return zoom.page(content, title='Apps')
def index(self):
if user.is_admin:
labels = (
'First Name',
'Last Name',
'Username',
'Password',
'Token',
'Expires',
'Action',
)
content = browse(registrations, labels=labels)
return page(content, title='Registrations')
messages = ul(get_errors(fields), Class='wrong')
form = fields.edit()
agreements = """
By registering, I agree to the <dz:site_name> <a
href="/terms.html">Terms of Use</a> and <a href="/privacy.html">Privacy
Policy</a>.
"""
content = load('registration.html')
return page(
content.format(fill=locals()),
css=load('style.css'),
)
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 index(self):
def get_group_link(group_id):
group = groups.get(group_id)
return group.link if group else zoom.html.span(
'missing',
title='unknown subgroup id {!r}'.format(group_id)
)
def fmt(app):
name = app.name
group_name = 'a_' + app.name
app_group = zoom.system.site.groups.first(name=group_name)
groups = ', '.join(
get_group_link(s) for g, s in subgroups if g == app_group._id
) if app_group else ''
return [
app.name,
app.title,
app.path,
groups,
]
db = zoom.system.site.db
subgroups = list(db('select * from subgroups'))
groups = dict((g._id, g) for g in zoom.system.site.groups)
data = [fmt(app) for app in sorted(zoom.system.site.apps, key=lambda a: a.name)]
content = zoom.browse(
data,
labels=['App', 'Title', 'Path', 'Groups']
)
return zoom.page(content, title='Apps')
def group_activity_log(group):
"""gathers log information for the group
Authorization activity related to groups is captured
by zoom and retreived from the audit_log table.
Note that system log entries are host specific,
however, audit logs are not host specific
as hosts sometimes share authozation databases and
thus changes in authorizations affect all hosts
using that database.
"""
query = """
select
app,
user_id,
activity,
subject1,
subject2,
timestamp
from audit_log
where subject2=%s
union select
app,
user_id,
activity,
subject1,
subject2,
timestamp
from audit_log
where
activity in (
"add group",
"remove group",
"create group",
"delete group",
"add member",
"remove member"
)
and subject1=%s
order by timestamp desc
limit 20
"""
db = zoom.system.site.db
items = [(app, zoom.helpers.who(user_id), activity, subject1, subject2,
timestamp, zoom.helpers.when(timestamp))
for app, user_id, activity, subject1, subject2, timestamp in db(
query, group.name, group.name)]
labels = [
'App', 'User', 'Activity', 'Subject1', 'Subject2', 'Timestamp', 'When'
]
auth_activity = zoom.browse(items, labels=labels)
return """
<h2>Recent Authorizations Activity<h2>
{}
""".format(auth_activity)
def _system_log(self):
self.model.site.logging = False
db = self.model.site.db
data = db("""
select
id, app, path, status, address, elapsed, message
from log
order by id desc limit 50
""")
return zoom.browse(data)
def index(self, q='', *args, **kwargs):
"""collection landing page"""
c = self.collection
user = c.user
if c.request.route[-1:] == ['index']:
return zoom.redirect_to('/'+'/'.join(c.request.route[:-1]), **kwargs)
actions = user.can('create', c) and ['New'] or []
if q:
title = 'Selected ' + c.title
records = c.search(q)
else:
title = c.title
records = c.store.find(type='U')
authorized = (i for i in records if user.can('read', i))
items = sorted(authorized, key=c.order)
num_items = len(items)
if num_items != 1:
footer_name = c.title.lower()
else:
footer_name = c.item_title.lower()
if q:
footer = '{:,} {} found in search of {:,} {}'.format(
num_items,
footer_name,
len(c.store),
c.title.lower(),
)
else:
footer = '%s %s' % (len(items), footer_name)
admin_ids = [item.admin_group_id for item in items]
admin_lookup = {
group.group_id: zoom.link_to(group.name, 'groups', group.group_id)
for group in zoom.system.site.groups
if group.group_id in admin_ids
}
for item in items:
item.administrators = admin_lookup.get(item.admin_group_id, '')
content = zoom.browse(
[c.model(i) for i in items],
labels=c.get_labels(),
columns=c.get_columns(),
footer=footer
)
return zoom.page(content, title=title, actions=actions, search=q)
def index(self, q=''):
content = callback(self._index)
if q:
request = zoom.system.request
users_collection = users.get_users_collection(request)
user_records = users_collection.search(q)
groups_collection = groups.get_groups_collection(request)
group_records = groups_collection.search(q)
if user_records or group_records:
content = zoom.Component()
if group_records:
footer = '%d groups found' % len(group_records)
content += zoom.browse(
group_records,
columns=groups_collection.columns,
labels=groups_collection.labels,
title='Groups',
footer=footer,
)
if user_records:
footer = '%d users found' % len(user_records)
content += zoom.browse(
user_records,
columns=users_collection.columns,
labels=users_collection.labels,
title='Users',
footer=footer,
)
else:
zoom.alerts.warning('no records found')
return page(
content,
title='Overview',
search=q
)
def list(self):
if zoom.system.request.user.is_admin:
labels = (
'First Name',
'Last Name',
'Username',
'Token',
'Expires',
'Action',
)
content = zoom.browse(model.get_registrations(), labels=labels)
return zoom.page(content, title='Registrations')
def index(self):
"""Returns a list of background jobs"""
jobs = zoom.sites.Site(zoom.system.site.path).get_background_jobs()
labels = 'Name', 'Path', 'Cron', 'Scheduled', 'Status'
content = zoom.browse(((
job.name,
job.path,
job.cron,
job.scheduled,
job.status,
) for job in jobs),
labels=labels)
title = 'Jobs <span class="meta"><small>alpha</small></span>'
return zoom.page(content, title=title)
def log_data(db, status, n, limit, q):
"""retreive log data"""
host = zoom.system.request.host
statuses = tuple(status)
offset = int(n) * int(limit)
cmd = """
select
id,
status,
user_id,
address,
app,
path,
timestamp,
elapsed
from log
where status in %s and server = %s
order by id desc
limit {limit}
offset {offset}
""".format(
limit=int(limit),
offset=offset,
statuses=statuses
)
data = db(cmd, statuses, host)
data = [
[
link_to(
str(item[0]),
'/admin/entry/' + str(item[0])
),
item[1],
zoom.helpers.who(item[2]),
] + list(item[3:])
for item in data
if q in repr(item)
]
labels = (
'id', 'status', 'user', 'address', 'app',
'path', 'timestamp', 'elapsed'
)
return zoom.browse(data, labels=labels)
def audit(self):
"""view audit log"""
def fmt(rec):
user = (zoom.helpers.who(rec[2]),)
when = (zoom.helpers.when(rec[-1]),)
return rec[0:2] + user + rec[3:-1] + when
db = self.model.site.db
data = list(map(fmt, db("""
select
*
from audit_log
order by id desc
limit 100"""
)))
labels = 'ID', 'App', 'By Whom', 'Activity', 'Subject 1', 'Subject 2', 'When'
return page(zoom.browse(data, labels=labels), title='Activity')
def view():
hr = '<hr>\n'
data = [('String', 'Integer', 'Decimal'),
('One', 1, decimal.Decimal(1234)),
('Two', 2, decimal.Decimal(2345))]
content = zoom.Component(
'zoom.browse',
zoom.browse(data, title='Sample Header',
footer='sample footer'), hr, 'zoom.components.HeaderBar',
c.HeaderBar(left=h.h2('HeaderBar Left'),
right='HeaderBar right'), hr, 'zoom.components.spinner',
h.div(c.spinner(),
classed="clearfix",
style="margin: 40px auto; width: 0;"), hr,
'zoom.components.dropzone', c.dropzone('/sample/components'), hr,
use_common_package('not updated yet'))
return zoom.page(content, title='Components')
def index():
"""app index"""
event_log = list(
zoom.system.site.db('''
select
log.message, log.timestamp
from
log join users on log.user_id = users.id
where log.app = "content" and log.status = 'A'
order by log.timestamp desc
limit 10;
'''))
parsed_log = list()
for row in event_log:
parsed_log.append((row[0], how_long_ago(row[1])))
parsed_log.insert(0, ('Event', 'When'))
content = zoom.browse(parsed_log, title='Recent Activity')
return zoom.page(
content,
title='Overview',
)
def index(self):
"""Returns a list of background jobs"""
actions = []
if zoom.system.user.is_admin:
actions.append(('Clear Placeholders', 'jobs/clear'))
jobs = zoom.sites.Site(zoom.system.site.path).background_jobs
lookup = {
job.qualified_name: job
for job in zoom.store_of(zoom.background.BackgroundJobPlaceholder)
}
when = zoom.helpers.when
labels = ('Name', 'Status', 'Trigger', 'Next Run', 'Last Run',
'Elapsed', 'Last Run Status')
content = zoom.browse(
((job.name, job.status, job.trigger, when(job.next_run),
when(
lookup.get(job.qualified_name)
and lookup.get(job.qualified_name).last_run) or 'never',
timespan(
lookup.get(job.qualified_name).last_finished
if job.qualified_name in lookup else None,
lookup[job.qualified_name].last_run
if job.qualified_name in lookup else None,
), lookup[job.qualified_name].last_run_status
if job.qualified_name in lookup
and lookup[job.qualified_name].last_run_status else '-')
for job in jobs),
labels=labels,
)
title = 'Jobs'
return zoom.page(content, title=title, actions=actions)
def user_activity_logs(user, weeks=12):
"""gathers log information for the user
The activity logs are comprised of both the user
activities within the system and the authorization
activities related to the user as captured in the
audit logs.
Note that the system log entries are host specific
so this app displays the activities for the host
it is on. However, audit logs are not host specific
as hosts sometimes share authozation databases and
thus changes in authorizations affect all hosts
using that database.
"""
max_len = 50
websafe = zoom.tools.websafe
db = zoom.system.site.db
when = zoom.helpers.when
who = zoom.helpers.who
auth_data = db(
"""
select *
from audit_log
where
(subject1=%s or subject2=%s)
order by timestamp desc
limit 20
""", user.username, user.username)
labels = 'App', 'User', 'Activity', 'Subject1', 'Subject2', 'When'
auth_activity = zoom.browse(
[(a[1], who(a[2]), a[3], a[4], a[5], when(a[6])) for a in auth_data],
labels=labels)
activity_data = db(
"""
select
id, timestamp, path, status, address, elapsed, message
from log
where
user_id=%s
and server=%s
order by timestamp desc
limit 50
""", user.user_id, zoom.system.request.host)
labels = ('id', 'Path', 'Status', 'Address', 'When', 'Elapsed', 'Message')
activity = zoom.browse([(zoom.helpers.link_to_page(
a[0], 'entry', a[0]), a[2], a[3], a[4], zoom.helpers.when(
a[1]), a[5], a[6] if a[3] == 'A' else websafe(a[6][:max_len]))
for a in activity_data],
labels=labels)
return """
<h2>Most Recent Authorizations Activity</h2>
%s
<h2>Most Recent User Activity</h2>
%s
""" % (auth_activity, activity)
