sections = [
('Settings', [
('Connection', str(zoom.tools.websafe(zoom.system.site.db))),
('Isolation Level', get_isolation_level(zoom.system.site.db))
]),
('Process List', zoom.system.site.db('show processlist')),
('Status', zoom.system.site.db('show status')),
]
if db('show slave hosts'):
sections.extend([
('Replication Hosts', db('show slave hosts')),
('Replication Status', db('show slave status'))
])
content = zoom.Component(
*((h.h2(title), h.table(code)) for title, code in sections),
css="""
.content table { width: 100%; }
.content table td {width: 50%; }
"""
)
else:
content = 'not available for {} database engine'.format(engine)
return zoom.page(content, title='Database')
main = zoom.dispatch(DatabaseView)
@authorize('managers')
def upload(self, *route, **req_data):
"""Handle a file upload."""
# Read the FieldStorage.
file_desc = req_data['file']
file_mimetype = req_data['mimetype']
if not isinstance(file_desc, FieldStorage):
# Python is dangerous when the type is incorrectly assumed.
return Response(b'invalid request body', status='400 Bad Request')
# Persist the file.
data_id = get_bucket().put(file_desc.value)
to_store = StoredFile(id=uuid4().hex,
data_id=data_id,
mimetype=file_mimetype,
content_length=len(file_desc.value),
original_name=file_desc.filename)
StoredFile.collection().put(to_store)
log_activity('%s uploaded file %s' %
(context.user.link, to_store.access_link))
# Respond.
return Response(bytes(to_store.access_url, 'utf-8'),
status='201 Created')
# Define main.
main = dispatch(FileSetController, FileSetView)
layout = Layout()
actions = ['Change Password']
return zoom.page(
layout.format(form=form.show()),
title='Profile',
# actions=actions
)
def change_password(self, **_):
"""Change Password Form"""
form = zoom.Form(
model.change_password_fields(),
zoom.fields.ButtonField('Change Password', cancel='/profile'))
return zoom.page(form.edit(), title='Change Password')
def change_photo(self, **_):
"""Change Photo"""
form = zoom.Form(
model.change_photo_fields(),
zoom.fields.ButtonField('Change Photo', cancel='/profile'))
return zoom.page(form.edit(), title='Change Photo')
main = zoom.dispatch(ProfileController)
'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')
main = zoom.dispatch(AppsController)
image_name=name,
draft=True,
)
images = zoom.store.store_of(Image)
images.put(image)
return item_id
def remove_image(self, *_, **kwargs):
"""remove a dropzone image"""
# k contains item_id and filename for file to be removed
item_id = kwargs.get('id', None)
# detach the image from the record
if item_id:
images = zoom.store.store_of(Image)
key = images.first(image_id=item_id)
if key:
images.delete(key)
# delete the bucket
path = os.path.join(zoom.system.site.data_path, 'buckets')
bucket = Bucket(path)
if item_id in bucket.keys():
bucket.delete(item_id)
return 'ok'
return 'empty'
main = zoom.dispatch(ImageManager)
def save_button(self, *args, **kwargs):
if args and args[0] == 'site':
if self.site_form.validate(kwargs):
model.save_site_settings(self.site_form.evaluate())
zoom.alerts.success('site settings saved')
return zoom.home(args[0])
return None
if args and args[0] == 'theme':
if self.theme_form.validate(kwargs):
model.save_theme_settings(self.theme_form.evaluate())
zoom.alerts.success('theme settings saved')
return zoom.home(args[0])
return None
if args and args[0] == 'mail':
if self.mail_form.validate(kwargs):
model.save_mail_settings(self.mail_form.evaluate())
zoom.alerts.success('mail settings saved')
return zoom.home(args[0])
return None
def __call__(self, *args, **kwargs):
response = zoom.mvc.Controller.__call__(self, *args, **kwargs)
return self.menu.page(response)
main = zoom.dispatch(SettingsController, SettingsView)
"""
App Index
Provides the main index for the app.
"""
import zoom
class IndexView(zoom.View):
"""This Zoom "view" serves both an index and about page."""
def index(self):
"""Index page."""
return zoom.page('My Zoom app!', title='Overview')
def about(self):
"""About page."""
content = '{app.description}'
return zoom.page(
content.format(app=zoom.system.request.app),
title='About {app.title}'.format(app=zoom.system.request.app))
main = zoom.dispatch(IndexView)
"""
basic index
"""
import zoom
class MyView(zoom.View):
"""Index View"""
def index(self):
"""Index page"""
return zoom.page('Content goes here', title='Overview')
def about(self):
"""About page"""
content = '{app.description}'
return zoom.page(
content.format(app=zoom.system.request.app),
title='About {app.title}'.format(app=zoom.system.request.app))
main = zoom.dispatch(MyView)
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)
@zoom.authorize('administrators')
def clear(self):
zoom.store_of(zoom.background.BackgroundJobPlaceholder).zap()
return zoom.home('jobs')
main = zoom.dispatch(BackgroundController)
* [Missing (404)](/sample/responses/missing)
* [Exception (500)](/sample/responses/exception)
""")
def string(self):
return '<h1>Str</h1>This is a <code>str</code> response.'
def dictionary(self):
return dict(name='Dict Response', content='This is a dict response.')
def record(self):
return Person(
name='Record Response',
address='1234 Somwhere St',
content='This is a zoom.Record response.',
)
def text(self):
t = 'This is a TextResponse response.'
return zoom.response.TextResponse(t)
def component(self):
return zoom.Component(
'<h1>Component</h1>This is a <code>Component</code> response.')
def exception(self):
raise Exception("Test Exception")
main = zoom.dispatch(View)
logger.debug('login_button called')
site = zoom.system.request.site
username = data.get('username')
password = data.get('password')
remember_me = bool(data.get('remember_me'))
if username and password:
user = site.users.first(username=username, status='A')
if user:
if user.login(zoom.system.request, password, remember_me):
logger.info('user %s sucesfully logged in', username)
logger.debug(data)
if 'original_url' in data:
logger.debug('redirecting to %r', data['original_url'])
return zoom.redirect_to(data['original_url'])
return zoom.redirect_to('/')
logger.debug('failed login attempt for user %s', username)
error('incorrect username or password')
elif username:
error('password missing')
else:
error('username missing')
main = zoom.dispatch(LoginController, LoginView)
@cron('* * * * *')
def tick():
"""store the current timestamp"""
site = zoom.system.site
events = zoom.store_of(Event)
event = events.first(site=site.name) or Event(site=site.name, counter=1)
event.timestamp = zoom.tools.now()
event.counter += 1
event_id = events.put(event)
return event_id
class TickEventView(zoom.View):
def index(self):
site = zoom.system.site
events = zoom.store_of(Event)
event = events.first(site=site.name)
if event:
msg = 'Tick {event.counter:,} happened {event.when}'
message = msg.format(event=event)
else:
message = 'No ticks yet. Background process may not be active.'
return zoom.page(message, title='Background')
main = zoom.dispatch(TickEventView)
